@evoscientist/webui 0.2.4 → 0.2.6

package/dist/node_modules/next/dist/server/request/params.js

@@ -42,7 +42,7 @@ const _reflectutils = require("../../shared/lib/utils/reflect-utils");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
 const _dynamicaccessasyncstorageexternal = require("../app-render/dynamic-access-async-storage.external");
-const _stagedrendering = require("../app-render/staged-rendering");
+const _paramsutils = require("../lib/params-utils");
 function createParamsFromClient(underlyingParams) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
@@ -64,8 +64,6 @@ function createParamsFromClient(underlyingParams) {
                 // tracked by the server.
                 const varyParamsAccumulator = null;
                 return createStaticPrerenderParams(underlyingParams, null, workStore, workUnitStore, varyParamsAccumulator);
-            case 'validation-client':
-                return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
@@ -86,19 +84,25 @@ function createParamsFromClient(underlyingParams) {
                     enumerable: false,
                     configurable: true
                 });
+            case 'validation-client':
+                {
+                    if (workUnitStore.validationSamples) {
+                        return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
+                    }
+                    return makeUntrackedParams(underlyingParams);
+                }
             case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // 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.
-                    const fallbackParams = workUnitStore.fallbackParams;
-                    // Client params are not runtime prefetchable
-                    const isRuntimePrefetchable = false;
-                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
-                } else if (workUnitStore.validationSamples) {
-                    return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
+                {
+                    if (workUnitStore.validationSamples) {
+                        return createClientParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples);
+                    }
+                    if (process.env.NODE_ENV === 'development') {
+                        const fallbackParams = workUnitStore.fallbackParams;
+                        const userspaceParams = underlyingParams;
+                        return createRenderParamsInDev(underlyingParams, userspaceParams, fallbackParams, workStore, workUnitStore);
+                    } else {
+                        return createRenderParamsInProd(underlyingParams);
+                    }
                 }
             default:
                 workUnitStore;
@@ -106,9 +110,9 @@ function createParamsFromClient(underlyingParams) {
     }
     (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
 }
-function createServerParamsForMetadata(underlyingParams, optionalCatchAllParamName, isRuntimePrefetchable) {
+function createServerParamsForMetadata(underlyingParams, optionalCatchAllParamName) {
     const metadataVaryParamsAccumulator = (0, _varyparams.getMetadataVaryParamsAccumulator)();
-    return createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, metadataVaryParamsAccumulator, isRuntimePrefetchable);
+    return createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, metadataVaryParamsAccumulator);
 }
 function createServerParamsForRoute(underlyingParams, varyParamsAccumulator = null) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
@@ -149,19 +153,17 @@ function createServerParamsForRoute(underlyingParams, varyParamsAccumulator = nu
                 });
             case 'prerender-runtime':
                 {
-                    // Route params are not runtime prefetchable
-                    const isRuntimePrefetchable = false;
-                    return createRuntimePrerenderParams(underlyingParams, null, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
+                    throw Object.defineProperty(new _invarianterror.InvariantError('createServerParamsForRoute should not be called in runtime prerenders.'), "__NEXT_ERROR_CODE", {
+                        value: "E1367",
+                        enumerable: false,
+                        configurable: true
+                    });
                 }
             case 'request':
                 if (process.env.NODE_ENV === 'development') {
-                    // 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.
                     const fallbackParams = workUnitStore.fallbackParams;
-                    // Route params are not runtime prefetchable
-                    const isRuntimePrefetchable = false;
-                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
+                    const userspaceParams = underlyingParams;
+                    return createRenderParamsInDev(underlyingParams, userspaceParams, fallbackParams, workStore, workUnitStore);
                 } else {
                     return createRenderParamsInProd(underlyingParams);
                 }
@@ -171,7 +173,7 @@ function createServerParamsForRoute(underlyingParams, varyParamsAccumulator = nu
     }
     (0, _workunitasyncstorageexternal.throwInvariantForMissingStore)();
 }
-function createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, varyParamsAccumulator, isRuntimePrefetchable) {
+function createServerParamsForServerSegment(underlyingParams, optionalCatchAllParamName, varyParamsAccumulator) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     if (!workStore) {
         throw Object.defineProperty(new _invarianterror.InvariantError('Expected workStore to be initialized'), "__NEXT_ERROR_CODE", {
@@ -209,20 +211,10 @@ function createServerParamsForServerSegment(underlyingParams, optionalCatchAllPa
                     configurable: true
                 });
             case 'prerender-runtime':
-                return createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable);
+                return createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, workUnitStore, varyParamsAccumulator);
             case 'request':
-                if (process.env.NODE_ENV === 'development') {
-                    // 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.
-                    const fallbackParams = workUnitStore.fallbackParams;
-                    return createRenderParamsInDev(underlyingParams, fallbackParams, workStore, workUnitStore, isRuntimePrefetchable);
-                } else if (workUnitStore.asyncApiPromises && workUnitStore.validationSamples) {
-                    return createServerParamsInInstantValidation(underlyingParams, workStore, workUnitStore.validationSamples, workUnitStore.asyncApiPromises, isRuntimePrefetchable);
-                } else if (workUnitStore.asyncApiPromises && hasFallbackRouteParams(underlyingParams, workUnitStore.fallbackParams)) {
-                    return (isRuntimePrefetchable ? workUnitStore.asyncApiPromises.earlySharedParamsParent : workUnitStore.asyncApiPromises.sharedParamsParent).then(()=>underlyingParams);
-                } else {
-                    return createRenderParamsInProd(underlyingParams);
+                {
+                    return createRenderParamsForPage(workStore, workUnitStore, underlyingParams, optionalCatchAllParamName, varyParamsAccumulator);
                 }
             default:
                 workUnitStore;
@@ -252,7 +244,7 @@ function createPrerenderParamsForClientSegment(underlyingParams) {
                             // to consider the awaiting of this params object "dynamic". Since
                             // we are in cacheComponents mode we encode this as a promise that never
                             // resolves.
-                            return (0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`params`');
+                            return (0, _dynamicrenderingutils.makeFallbackParamsHangingPromise)(workUnitStore.renderSignal, workStore.route, '`params`', workUnitStore);
                         }
                     }
                 }
@@ -278,9 +270,9 @@ function createPrerenderParamsForClientSegment(underlyingParams) {
                     enumerable: false,
                     configurable: true
                 });
+            case 'prerender-runtime':
             case 'prerender-ppr':
             case 'prerender-legacy':
-            case 'prerender-runtime':
             case 'request':
                 break;
             default:
@@ -293,9 +285,36 @@ function createPrerenderParamsForClientSegment(underlyingParams) {
     return Promise.resolve(underlyingParams);
 }
 function createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, prerenderStore, varyParamsAccumulator) {
-    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
     switch(prerenderStore.type){
         case 'prerender':
+            {
+                let userspaceParams = underlyingParams;
+                if (varyParamsAccumulator !== null) {
+                    userspaceParams = (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName);
+                }
+                if ((0, _paramsutils.isEmptyParams)(underlyingParams)) {
+                    // This route has no params.
+                    return makeUntrackedParams(userspaceParams);
+                }
+                const fallbackParams = prerenderStore.fallbackRouteParams;
+                if ((0, _paramsutils.hasFallbackRouteParams)(underlyingParams, fallbackParams)) {
+                    // This params object has one or more fallback params, so we need
+                    // to consider the awaiting of this params object dynamic.
+                    return makeHangingParams(underlyingParams, workStore, prerenderStore);
+                }
+                // All params are static.
+                const { stagedRendering } = prerenderStore;
+                if (stagedRendering) {
+                    // Even if all params are static, we need to exclude them from the app shell
+                    // by delaying them to the static stage. However, root params are allowed in shells,
+                    // so if all the params are root params, they can be included as well.
+                    if (!(0, _paramsutils.allParamsAreRootParams)(underlyingParams, prerenderStore.rootParams)) {
+                        const staticParamsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticLinkData;
+                        return stagedRendering.delayUntilStage(staticParamsStage, 'params', userspaceParams);
+                    }
+                }
+                return makeUntrackedParams(userspaceParams);
+            }
         case 'prerender-client':
             {
                 const fallbackParams = prerenderStore.fallbackRouteParams;
@@ -306,7 +325,7 @@ function createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName
                             // to consider the awaiting of this params object "dynamic". Since
                             // we are in cacheComponents mode we encode this as a promise that never
                             // resolves.
-                            return makeHangingParams(underlyingParamsWithVarying, workStore, prerenderStore);
+                            return makeHangingParams(underlyingParams, workStore, prerenderStore);
                         }
                     }
                 }
@@ -318,7 +337,7 @@ function createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName
                 if (fallbackParams) {
                     for(const key in underlyingParams){
                         if (fallbackParams.has(key)) {
-                            return makeErroringParams(underlyingParamsWithVarying, fallbackParams, workStore, prerenderStore);
+                            return makeErroringParams(underlyingParams, fallbackParams, workStore, prerenderStore);
                         }
                     }
                 }
@@ -329,33 +348,124 @@ function createStaticPrerenderParams(underlyingParams, optionalCatchAllParamName
         default:
             prerenderStore;
     }
-    return makeUntrackedParams(underlyingParamsWithVarying);
+    let userspaceParams = underlyingParams;
+    if (varyParamsAccumulator !== null) {
+        userspaceParams = (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName);
+    }
+    return makeUntrackedParams(userspaceParams);
 }
-function createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workUnitStore, varyParamsAccumulator, isRuntimePrefetchable) {
-    const underlyingParamsWithVarying = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName) : underlyingParams;
-    const result = makeUntrackedParams(underlyingParamsWithVarying);
+function createRuntimePrerenderParams(underlyingParams, optionalCatchAllParamName, workStore, workUnitStore, varyParamsAccumulator) {
+    let userspaceParams = underlyingParams;
+    if (varyParamsAccumulator !== null) {
+        userspaceParams = (0, _varyparams.createVaryingParams)(varyParamsAccumulator, underlyingParams, optionalCatchAllParamName);
+    }
+    if ((0, _paramsutils.isEmptyParams)(underlyingParams)) {
+        // This route has no params.
+        return makeUntrackedParams(userspaceParams);
+    }
     const { stagedRendering } = workUnitStore;
     if (!stagedRendering) {
-        return result;
+        // If there's no staging, we're in a prospective runtime prerender.
+        if (workUnitStore.isSessionShell) {
+            // If we're warming up for a session shell, params should be hanging,
+            // because they'll be a hanging input in the final prerender.
+            return makeHangingParams(underlyingParams, workStore, workUnitStore);
+        } else {
+            return makeUntrackedParams(userspaceParams);
+        }
+    }
+    // We don't have fallbackParams in runtime prerenders, so we don't know
+    // when params are static. However, root params are static by definition,
+    // so we can at least check for that.
+    // Note that resolving them without a delay is valid because root params are
+    // allowed in shells.
+    if ((0, _paramsutils.allParamsAreRootParams)(underlyingParams, workUnitStore.rootParams)) {
+        return makeUntrackedParams(userspaceParams);
     }
-    const stage = isRuntimePrefetchable ? _stagedrendering.RenderStage.EarlyRuntime : _stagedrendering.RenderStage.Runtime;
-    return stagedRendering.waitForStage(stage).then(()=>result);
+    // Semantically, we should resolve static params in the static stage.
+    // But params are link data, and we need to recover a param-less session shell,
+    // so we delay all params until the runtime stage instead.
+    const staticParamsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
+    return stagedRendering.delayUntilStage(staticParamsStage, 'params', userspaceParams);
 }
-function hasFallbackRouteParams(underlyingParams, fallbackParams) {
-    if (fallbackParams) {
-        for(let key in underlyingParams){
-            if (fallbackParams.has(key)) {
-                return true;
-            }
-        }
+function createRenderParamsForPage(workStore, workUnitStore, underlyingParams, optionalCatchAllParamName, varyParamsAccumulator) {
+    const { stagedRendering, asyncApiPromises, validationSamples } = workUnitStore;
+    // Distinguish the params that we expose to userspace (potentially wrapped in proxies)
+    // and the underlying object containing params values. We do this because wrappers
+    // like `instrumentParamsPromiseWithDevWarnings` need to be able to get the known param names
+    // without triggering other wrapper proxies.
+    let userspaceParams = underlyingParams;
+    if (validationSamples) {
+        userspaceParams = createServerParamsProxyForInstantValidation(underlyingParams, workStore, validationSamples);
+    }
+    if (varyParamsAccumulator) {
+        userspaceParams = (0, _varyparams.createVaryingParams)(varyParamsAccumulator, userspaceParams, optionalCatchAllParamName);
+    }
+    if (stagedRendering && asyncApiPromises) {
+        return createStagedRenderParams(workStore, workUnitStore, stagedRendering, asyncApiPromises, underlyingParams, userspaceParams);
+    }
+    // No staged rendering = no cacheComponents, or cacheComponents prod without cachedNavigations
+    if (process.env.NODE_ENV === 'development') {
+        const fallbackParams = workUnitStore.fallbackParams;
+        return createRenderParamsInDev(underlyingParams, userspaceParams, fallbackParams, workStore, workUnitStore);
+    } else {
+        return createRenderParamsInProd(userspaceParams);
+    }
+}
+function createStagedRenderParams(workStore, workUnitStore, stagedRendering, asyncApiPromises, underlyingParams, userspaceParams) {
+    const promise = createStagedRenderParamsImpl(workUnitStore, stagedRendering, asyncApiPromises, underlyingParams, userspaceParams);
+    if (process.env.NODE_ENV === 'development') {
+        return instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
+    } else {
+        return promise;
+    }
+}
+function createStagedRenderParamsImpl(workUnitStore, stagedRendering, asyncApiPromises, /** The actual param values, without any instrumentation */ underlyingParams, /** The params object to return to userspace, possibly wrapped in a proxy */ userspaceParams) {
+    // If the route has no params, they should resolve immediately.
+    if ((0, _paramsutils.isEmptyParams)(underlyingParams)) {
+        return makeUntrackedParams(userspaceParams);
+    }
+    // If we have fallback params, then they should always resolve in the runtime link data stage.
+    // We do this indirectly via the shared params parent for better debug info.
+    if ((0, _paramsutils.hasFallbackRouteParams)(underlyingParams, workUnitStore.fallbackParams)) {
+        return createParamsPromiseFromTrigger(asyncApiPromises.sharedParamsParent, userspaceParams);
+    }
+    // All params are static.
+    // If we're rendering with shells, even static params must be delayed to exclude them from the shell.
+    // However, root params are allowed in shells, so if all the params are root params, they can be included as well.
+    if (!(0, _paramsutils.allParamsAreRootParams)(underlyingParams, workUnitStore.rootParams)) {
+        // For a dynamic request we generally want to recover a static shell,
+        // so static params can resolve in the static stage, because session
+        // shells are handled with a separate render.
+        // However, in dev we might need to recover a session shell for instant validation.
+        // This is indicated by `needsSessionShell`.
+        const staticParamsStage = workUnitStore.needsSessionShell ? _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData : _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.staticLinkData;
+        return stagedRendering.delayUntilStage(staticParamsStage, 'params', userspaceParams);
+    }
+    return makeUntrackedParams(userspaceParams);
+}
+function createParamsPromiseFromTrigger(trigger, userspaceParams) {
+    if (process.env.NODE_ENV === 'development') {
+        // We wrap each instance of params in a `new Promise()`, which lets us show each
+        // await a different set of values. This is important when all awaits
+        // are in third party which would otherwise track all the way to the
+        // internal params.
+        const promise = new Promise((resolve, reject)=>{
+            trigger.then(()=>resolve(userspaceParams), reject);
+        });
+        promise.catch(noop);
+        // @ts-expect-error
+        promise.displayName = 'params';
+        return promise;
+    } else {
+        return (0, _dynamicrenderingutils.makePromiseFromTrigger)(trigger, userspaceParams);
     }
-    return false;
 }
-function createServerParamsInInstantValidation(underlyingParams, workStore, validationSamples, asyncApiPromises, isRuntimePrefetchable) {
+function noop() {}
+function createServerParamsProxyForInstantValidation(underlyingParams, workStore, validationSamples) {
     const { createExhaustiveParamsProxy } = require('../app-render/instant-validation/instant-samples');
     const declaredParams = new Set(Object.keys(validationSamples.params ?? {}));
-    const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
-    return (isRuntimePrefetchable ? asyncApiPromises.earlySharedParamsParent : asyncApiPromises.sharedParamsParent).then(()=>proxiedUnderlying);
+    return createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
 }
 function createClientParamsInInstantValidation(underlyingParams, workStore, validationSamples) {
     const { createExhaustiveParamsProxy } = require('../app-render/instant-validation/instant-samples');
@@ -363,11 +473,11 @@ function createClientParamsInInstantValidation(underlyingParams, workStore, vali
     const proxiedUnderlying = createExhaustiveParamsProxy(underlyingParams, declaredParams, workStore.route);
     return Promise.resolve(proxiedUnderlying);
 }
-function createRenderParamsInProd(underlyingParams) {
-    return makeUntrackedParams(underlyingParams);
+function createRenderParamsInProd(userspaceParams) {
+    return makeUntrackedParams(userspaceParams);
 }
-function createRenderParamsInDev(underlyingParams, fallbackParams, workStore, requestStore, isRuntimePrefetchable) {
-    return makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackRouteParams(underlyingParams, fallbackParams), workStore, requestStore, isRuntimePrefetchable);
+function createRenderParamsInDev(underlyingParams, userpaceParams, fallbackParams, workStore, requestStore) {
+    return makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, userpaceParams, (0, _paramsutils.hasFallbackRouteParams)(underlyingParams, fallbackParams), workStore, requestStore);
 }
 const CachedParams = new WeakMap();
 const fallbackParamsProxyHandler = {
@@ -376,6 +486,14 @@ const fallbackParamsProxyHandler = {
             const originalMethod = _reflect.ReflectAdapter.get(target, prop, receiver);
             return ({
                 [prop]: (...args)=>{
+                    // Record against the store that's active at access time: the
+                    // hanging promise is cached by params object across prerender
+                    // stores, so the store that created it may not be the one that's
+                    // rendering when it's finally awaited.
+                    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+                    if (workUnitStore !== undefined) {
+                        (0, _dynamicrenderingutils.trackFallbackParamsAccessed)(workUnitStore);
+                    }
                     const store = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
                     if (store) {
                         store.abortController.abort(Object.defineProperty(new Error(`Accessed fallback \`params\` during prerendering.`), "__NEXT_ERROR_CODE", {
@@ -396,7 +514,10 @@ function makeHangingParams(underlyingParams, workStore, prerenderStore) {
     if (cachedParams) {
         return cachedParams;
     }
-    const promise = new Proxy((0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`params`'), fallbackParamsProxyHandler);
+    const promise = new Proxy((0, _dynamicrenderingutils.makeFallbackParamsHangingPromise)(prerenderStore.renderSignal, workStore.route, '`params`', // This promise is created for every segment on a fallback route whether
+    // or not it reads params, so recording the access at creation would mark
+    // every render. The access is tracked in the proxy traps instead.
+    null), fallbackParamsProxyHandler);
     CachedParams.set(underlyingParams, promise);
     return promise;
 }
@@ -452,21 +573,7 @@ function makeUntrackedParams(underlyingParams) {
     CachedParams.set(underlyingParams, promise);
     return promise;
 }
-function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallbackParams, workStore, requestStore, isRuntimePrefetchable) {
-    if (requestStore.asyncApiPromises && hasFallbackParams) {
-        // We wrap each instance of params in a `new Promise()`, because deduping
-        // them across requests doesn't work anyway and this let us show each
-        // await a different set of values. This is important when all awaits
-        // are in third party which would otherwise track all the way to the
-        // internal params.
-        const sharedParamsParent = isRuntimePrefetchable ? requestStore.asyncApiPromises.earlySharedParamsParent : requestStore.asyncApiPromises.sharedParamsParent;
-        const promise = new Promise((resolve, reject)=>{
-            sharedParamsParent.then(()=>resolve(underlyingParams), reject);
-        });
-        // @ts-expect-error
-        promise.displayName = 'params';
-        return instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
-    }
+function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, userspaceParams, hasFallbackParams, workStore, requestStore) {
     const cachedParams = CachedParams.get(underlyingParams);
     if (cachedParams) {
         return cachedParams;
@@ -474,7 +581,7 @@ function makeDynamicallyTrackedParamsWithDevWarnings(underlyingParams, hasFallba
     // We don't use makeResolvedReactPromise here because params
     // supports copying with spread and we don't want to unnecessarily
     // instrument the promise with spreadable properties of ReactPromise.
-    const promise = hasFallbackParams ? (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingParams, requestStore, _stagedrendering.RenderStage.Runtime) : Promise.resolve(underlyingParams);
+    const promise = hasFallbackParams ? (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(userspaceParams, requestStore, _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData) : Promise.resolve(userspaceParams);
     const proxiedPromise = instrumentParamsPromiseWithDevWarnings(underlyingParams, promise, workStore);
     CachedParams.set(underlyingParams, proxiedPromise);
     return proxiedPromise;

package/dist/node_modules/next/dist/server/request/pathname.js

@@ -53,8 +53,27 @@ function createServerPathnameForMetadata(underlyingPathname) {
                     configurable: true
                 });
             case 'prerender-runtime':
-                return (0, _dynamicrenderingutils.delayUntilRuntimeStage)(workUnitStore, createRenderPathname(underlyingPathname));
+                {
+                    // TODO(app-shells): whether or not this is included in the shell
+                    // should depend on whether this route has params.
+                    // if there's no params, it can be included.
+                    // for now, we defensively exclude it to match the earlier pessimistic
+                    // behavior of always resolving in the runtime stage
+                    // (i.e. assuming that we have non-static params in the pathname)
+                    const { stagedRendering } = workUnitStore;
+                    if (stagedRendering) {
+                        const pathnameStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
+                        return stagedRendering.delayUntilStage(pathnameStage, undefined, underlyingPathname);
+                    } else {
+                        if (workUnitStore.isSessionShell) {
+                            return (0, _dynamicrenderingutils.makeDynamicHangingPromise)(workUnitStore.renderSignal, workStore.route, '`pathname`');
+                        } else {
+                            return createRenderPathname(underlyingPathname);
+                        }
+                    }
+                }
             case 'request':
+                // TODO(app-shells): this should be delayed if there's non-static params
                 return createRenderPathname(underlyingPathname);
             default:
                 workUnitStore;
@@ -68,7 +87,10 @@ function createPrerenderPathname(underlyingPathname, workStore, prerenderStore)
             {
                 const fallbackParams = prerenderStore.fallbackRouteParams;
                 if (fallbackParams && fallbackParams.size > 0) {
-                    return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`pathname`');
+                    // The pathname only hangs when there are fallback params, and a
+                    // concrete (ISR-upgraded) prerender resolves it — so this access is
+                    // fallback-param data for the static-prefetch hint.
+                    return (0, _dynamicrenderingutils.makeFallbackParamsHangingPromise)(prerenderStore.renderSignal, workStore.route, '`pathname`', prerenderStore);
                 }
                 break;
             }

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

@@ -106,6 +106,14 @@ function getRootParam(paramName) {
                 break;
             }
         case 'private-cache':
+            {
+                // In dev, private caches are persisted and keyed by root params (like
+                // public caches), so we track which ones were read.
+                if (workUnitStore.readRootParamNames) {
+                    workUnitStore.readRootParamNames.add(paramName);
+                }
+                break;
+            }
         case 'prerender-runtime':
             {
                 break;
@@ -143,7 +151,7 @@ function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, a
                 // We are in a cacheComponents prerender.
                 // The param is a fallback, so it should be treated as dynamic.
                 if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
-                    return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, apiName);
+                    return (0, _dynamicrenderingutils.makeFallbackParamsHangingPromise)(prerenderStore.renderSignal, workStore.route, apiName, prerenderStore);
                 }
                 break;
             }