failproofai 1.0.11-beta.0 → 1.0.11-beta.2

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

@@ -9,76 +9,60 @@ Object.defineProperty(exports, "getRootParam", {
     }
 });
 const _invarianterror = require("../../shared/lib/invariant-error");
-const _dynamicrendering = require("../app-render/dynamic-rendering");
 const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
-const _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const _dynamicaccessasyncstorageexternal = require("../app-render/dynamic-access-async-storage.external");
 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: "E1032",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError(`Missing workStore in ${apiName}`);
     }
     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: "E1006",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Route ${workStore.route} used ${apiName} outside of a Server Component. This is not allowed.`);
     }
     const actionStore = _actionasyncstorageexternal.actionAsyncStorage.getStore();
     if (actionStore) {
         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: "E1043",
-                enumerable: false,
-                configurable: true
-            });
+            throw 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.`);
         }
         if (actionStore.isAction && workUnitStore.phase === 'action') {
             // Actions are not fundamentally tied to a route (even if they're always submitted from some page),
             // so root params would be inconsistent if an action is called from multiple roots.
             // 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: "E1014",
-                enumerable: false,
-                configurable: true
-            });
+            throw 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.`);
         }
     }
     switch(workUnitStore.type){
         case 'unstable-cache':
             {
-                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
-                });
+                throw new Error(`Route ${workStore.route} used ${apiName} inside \`unstable_cache\`. This is not supported. Use \`"use cache"\` instead.`);
             }
         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
-                    });
+                    throw new Error(`Route ${workStore.route} used ${apiName} inside \`"use cache"\` nested within \`unstable_cache\`. Root params are not available in this context.`);
                 }
                 workUnitStore.readRootParamNames.add(paramName);
+                const prerenderStore = workUnitStore.fallbackRootParamsPrerender;
+                if (prerenderStore !== null && prerenderStore.fallbackRouteParams !== null && prerenderStore.fallbackRouteParams.has(paramName)) {
+                    return (0, _dynamicrenderingutils.trackPromiseUsed)((0, _dynamicrenderingutils.makeFallbackParamsHangingPromise)(prerenderStore.renderSignal, workStore.route, apiName, // Track access and cancel the cache together when consumed below.
+                    null), ()=>{
+                        (0, _dynamicrenderingutils.trackFallbackParamsAccessed)(prerenderStore, apiName);
+                        // Like fallback `params`, an unknown root makes the whole cache
+                        // invocation dynamic, even if it contains its own Suspense.
+                        (0, _dynamicaccessasyncstorageexternal.abortOnDynamicAccess)('fallback-params', new Error(`Accessed fallback root parameter "${paramName}" during prerendering.`));
+                    });
+                }
                 return Promise.resolve(workUnitStore.rootParams[paramName]);
             }
         case 'prerender':
-        case 'prerender-ppr':
         case 'prerender-legacy':
             {
                 return createPrerenderRootParamPromise(paramName, workStore, workUnitStore, apiName);
@@ -86,11 +70,7 @@ function getRootParam(paramName) {
         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
-                });
+                throw 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.`);
             }
         case 'request':
             {
@@ -107,25 +87,20 @@ function getRootParam(paramName) {
             }
         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;
+                workUnitStore.readRootParamNames.add(paramName);
+                return Promise.resolve(workUnitStore.rootParams[paramName]);
             }
         case 'prerender-runtime':
             {
                 break;
             }
-        case 'generate-static-params':
+        case 'build-time-generator':
             {
                 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
-                    });
+                    if (workUnitStore.functionName !== 'generateStaticParams') {
+                        throw new Error(`Route ${workStore.route} used ${apiName} inside \`${workUnitStore.functionName}\`, but the \`${paramName}\` parameter is not available in this build-time generator.`);
+                    }
+                    throw 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.`);
                 }
                 break;
             }
@@ -141,7 +116,6 @@ function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, a
     switch(prerenderStore.type){
         case 'prerender':
         case 'prerender-legacy':
-        case 'prerender-ppr':
         default:
     }
     const underlyingParams = prerenderStore.rootParams;
@@ -155,15 +129,6 @@ function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, a
                 }
                 break;
             }
-        case 'prerender-ppr':
-            {
-                // We aren't in a cacheComponents prerender, but the param is a fallback,
-                // so we need to make an erroring params object which will postpone/error if you access it
-                if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
-                    return makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName);
-                }
-                break;
-            }
         case 'prerender-legacy':
             {
                 break;
@@ -177,26 +142,5 @@ function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, a
     (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) {
-    const expression = (0, _reflectutils.describeStringPropertyAccess)(apiName, paramName);
-    // In most dynamic APIs, we also throw if `dynamic = "error"`.
-    // However, root params are only dynamic when we're generating a fallback shell,
-    // and even with `dynamic = "error"` we still support generating dynamic fallback shells.
-    // TODO: remove this comment when cacheComponents is the default since there will be no `dynamic = "error"`
-    switch(prerenderStore.type){
-        case 'prerender-ppr':
-            {
-                return (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
-            }
-        case 'prerender-legacy':
-            {
-                return (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
-            }
-        default:
-            {
-                prerenderStore;
-            }
-    }
-}
 
 //# sourceMappingURL=root-params.js.map

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

@@ -46,40 +46,23 @@ const _utils = require("./utils");
 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
-        });
+        throw new _invarianterror.InvariantError('Expected workStore to be initialized');
     }
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workUnitStore) {
         switch(workUnitStore.type){
             case 'prerender':
             case 'prerender-client':
-            case 'prerender-ppr':
             case 'prerender-legacy':
                 return createStaticPrerenderSearchParams(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",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in a runtime prerender.');
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E739",
-                    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
-                });
+                throw new _invarianterror.InvariantError('createSearchParamsFromClient should not be called in cache contexts.');
+            case 'build-time-generator':
+                throw new _invarianterror.InvariantError(`createSearchParamsFromClient should not be called inside ${workUnitStore.functionName}.`);
             case 'validation-client':
                 {
                     if (workUnitStore.validationSamples) {
@@ -102,40 +85,23 @@ function createServerSearchParamsForMetadata(underlyingSearchParams) {
 function createServerSearchParamsForServerPage(underlyingSearchParams, varyParamsAccumulator) {
     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
-        });
+        throw new _invarianterror.InvariantError('Expected workStore to be initialized');
     }
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     if (workUnitStore) {
         switch(workUnitStore.type){
             case 'prerender':
             case 'prerender-client':
-            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
-                });
+                throw new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in a client validation.');
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E747",
-                    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
-                });
+                throw new _invarianterror.InvariantError('createServerSearchParamsForServerPage should not be called in cache contexts.');
+            case 'build-time-generator':
+                throw new _invarianterror.InvariantError(`createServerSearchParamsForServerPage should not be called inside ${workUnitStore.functionName}.`);
             case 'prerender-runtime':
                 return createRuntimePrerenderSearchParams(underlyingSearchParams, workStore, workUnitStore, varyParamsAccumulator);
             case 'request':
@@ -149,11 +115,7 @@ function createServerSearchParamsForServerPage(underlyingSearchParams, varyParam
 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
-        });
+        throw new _invarianterror.InvariantError('Expected workStore to be initialized');
     }
     if (workStore.forceStatic) {
         // When using forceStatic we override all other logic and always just return an empty
@@ -167,34 +129,17 @@ function createPrerenderSearchParamsForClientPage() {
             case 'prerender-client':
                 // 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.makeRuntimeHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`', workUnitStore);
+                return (0, _dynamicrenderingutils.makeURLDataHangingPromise)(workUnitStore.renderSignal, workStore.route, '`searchParams`', workUnitStore);
             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
-                });
+                throw new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a client validation.');
             case 'prerender-runtime':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a runtime prerender.'), "__NEXT_ERROR_CODE", {
-                    value: "E768",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in a runtime prerender.');
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
-                throw Object.defineProperty(new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in cache contexts.'), "__NEXT_ERROR_CODE", {
-                    value: "E746",
-                    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':
+                throw new _invarianterror.InvariantError('createPrerenderSearchParamsForClientPage should not be called in cache contexts.');
+            case 'build-time-generator':
+                throw new _invarianterror.InvariantError(`createPrerenderSearchParamsForClientPage should not be called inside ${workUnitStore.functionName}.`);
             case 'prerender-legacy':
             case 'request':
                 return Promise.resolve({});
@@ -213,9 +158,10 @@ function createStaticPrerenderSearchParams(workStore, prerenderStore) {
     switch(prerenderStore.type){
         case 'prerender':
         case 'prerender-client':
-            // We are in a cacheComponents (PPR or otherwise) prerender
-            return makeHangingSearchParams(workStore, prerenderStore);
-        case 'prerender-ppr':
+            {
+                // We are in a cacheComponents (PPR or otherwise) prerender
+                return makeHangingSearchParams(workStore, prerenderStore);
+            }
         case 'prerender-legacy':
             // We are in a legacy static generation and need to interrupt the
             // prerender when search params are accessed.
@@ -226,28 +172,23 @@ function createStaticPrerenderSearchParams(workStore, prerenderStore) {
 }
 function createRuntimePrerenderSearchParams(underlyingSearchParams, workStore, workUnitStore, varyParamsAccumulator) {
     const userspaceSearchParams = varyParamsAccumulator !== null ? (0, _varyparams.createVaryingSearchParams)(varyParamsAccumulator, underlyingSearchParams) : underlyingSearchParams;
-    const result = makeUntrackedSearchParams(userspaceSearchParams);
+    const searchParamsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeUrlData;
     const { stagedRendering } = workUnitStore;
     if (!stagedRendering) {
-        // If there's no staging, we're in a prospective runtime prerender.
-        if (workUnitStore.isSessionShell) {
-            // If we're warming up for a session shell, search params should hang,
-            // because they'll be a hanging input in the final prerender.
+        // If there's no stage controller, we're in a prospective runtime prerender.
+        // Make sure we don't unblock content that won't be reached in the final prerender.
+        if (workUnitStore.finalStage < searchParamsStage) {
             return makeHangingSearchParams(workStore, workUnitStore);
+        } else {
+            return makeUntrackedSearchParams(userspaceSearchParams);
         }
-        return result;
     }
-    // Unlike `createRuntimePrerenderParams`, which uses `delayUntilStage`, we
-    // resolve with `waitForStage(...).then(...)` here. Switching search params to
-    // `delayUntilStage` drops the source code frame from the instant-validation
-    // "URL data outside of Suspense" error when a page awaits `searchParams` at
-    // the top level (params, read via a nested component, is unaffected). See the
-    // `missing suspense around search params` cases in the instant-validation
-    // `suspense-boundaries` tests. The underlying reason in React's async I/O
-    // await tracking isn't understood yet. TODO: align search params with params
-    // on `delayUntilStage` once resolved.
-    const searchParamsStage = _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData;
-    return stagedRendering.waitForStage(searchParamsStage).then(()=>result);
+    // If search params don't resolve in this prerender, caches need to treat them as a hanging input.
+    if (stagedRendering.finalStage && stagedRendering.finalStage < searchParamsStage) {
+        return makeHangingSearchParams(workStore, workUnitStore);
+    } else {
+        return stagedRendering.delayUntilStage(searchParamsStage, 'searchParams', userspaceSearchParams);
+    }
 }
 function createRenderSearchParams(underlyingSearchParams, workStore, requestStore) {
     const { asyncApiPromises, validationSamples } = requestStore;
@@ -302,16 +243,16 @@ function makeHangingSearchParams(workStore, prerenderStore) {
     if (cachedSearchParams) {
         return cachedSearchParams;
     }
-    const promise = (0, _dynamicrenderingutils.makeRuntimeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`searchParams`', // This promise is created for every page whether or not it reads search
-    // params, so recording the access at creation would mark every render.
-    // The access is tracked in the proxy traps below instead.
+    const promise = (0, _dynamicrenderingutils.makeURLDataHangingPromise)(prerenderStore.renderSignal, workStore.route, '`searchParams`', // Passing `null` for the store disables tracking of params usage.
+    // We want accesses of chained promises to be tracked as well.
+    // TODO: The custom tracking seems unnecessary, we should standardize it
     null);
     const trackSearchParamsAccessed = ()=>{
         // Record against the store that's active at access time: the promise is
         // created while the RSC payload is constructed, but typically accessed
         // later, during the render, under a different store.
         const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
-        (0, _dynamicrenderingutils.trackRuntimeDataAccessed)(workUnitStore ?? prerenderStore);
+        (0, _dynamicrenderingutils.trackURLDataAccessed)(workUnitStore ?? prerenderStore, '`searchParams`');
     };
     const proxyHandler = {
         get (target, prop, receiver) {
@@ -340,14 +281,7 @@ function makeHangingSearchParams(workStore, prerenderStore) {
                                 // stall the App Shell cache-warming render. Re-wrapping the
                                 // result propagates the same behavior to promises derived via
                                 // `.then`/`.catch`/`.finally` that are then passed into a cache.
-                                const dynamicAccessStore = _dynamicaccessasyncstorageexternal.dynamicAccessAsyncStorage.getStore();
-                                if (dynamicAccessStore) {
-                                    dynamicAccessStore.abortController.abort(Object.defineProperty(new Error('Accessed `searchParams` during prerendering.'), "__NEXT_ERROR_CODE", {
-                                        value: "E1449",
-                                        enumerable: false,
-                                        configurable: true
-                                    }));
-                                }
+                                (0, _dynamicaccessasyncstorageexternal.abortOnDynamicAccess)('runtime', new Error('Accessed `searchParams` during prerendering.'));
                                 return new Proxy(originalMethod.apply(target, args), proxyHandler);
                             }
                         })[prop];
@@ -392,9 +326,6 @@ function makeErroringSearchParams(workStore, prerenderStore) {
                 const expression = '`await searchParams`, `searchParams.then`, or similar';
                 if (workStore.dynamicShouldError) {
                     (0, _utils.throwWithStaticGenerationBailoutErrorWithDynamicError)(workStore.route, expression);
-                } else if (prerenderStore.type === 'prerender-ppr') {
-                    // PPR Prerender (no cacheComponents)
-                    (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
                 } else {
                     // Legacy Prerender
                     (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
@@ -409,11 +340,7 @@ function makeErroringSearchParams(workStore, prerenderStore) {
 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
-        });
+        throw new _invarianterror.InvariantError('Expected workStore to be initialized');
     }
     const cachedSearchParams = CachedSearchParamsForUseCache.get(workStore);
     if (cachedSearchParams) {
@@ -461,11 +388,11 @@ function makeUntrackedSearchParamsWithDevWarningsImpl(underlyingSearchParams, wo
         current: false
     };
     const proxiedUnderlying = instrumentSearchParamsObjectWithDevWarnings(underlyingSearchParams, workStore, promiseInitialized);
-    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(proxiedUnderlying, requestStore, _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeLinkData);
+    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(proxiedUnderlying, requestStore, _dynamicrenderingutils.RENDER_STAGES_BY_DATA_KIND.runtimeUrlData);
     promise.then(()=>{
         promiseInitialized.current = true;
     }, // If we're in staged rendering, this promise will reject if the render
-    // is aborted before it can reach the runtime stage.
+    // is aborted before it can reach the PrefetchRuntime stage.
     // In that case, we have to prevent an unhandled rejection from the promise
     // created by this `.then()` call.
     // This does not affect the `promiseInitialized` logic above,
@@ -565,11 +492,7 @@ function instrumentSearchParamsPromiseWithDevWarnings(underlyingSearchParams, pr
 const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createSearchAccessError);
 function createSearchAccessError(route, expression) {
     const prefix = route ? `Route "${route}" ` : 'This route ';
-    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`searchParams\` is a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
-        value: "E848",
-        enumerable: false,
-        configurable: true
-    });
+    return new Error(`${prefix}used ${expression}. ` + `\`searchParams\` is a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`);
 }
 function createClientSearchParamsInValidation(underlyingSearchParams, workStore, workUnitStore) {
     var _workUnitStore_validationSamples;

package/.next/standalone/node_modules/next/dist/server/request/utils.js

@@ -27,19 +27,12 @@ _export(exports, {
 const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
 const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
 const _aftertaskasyncstorageexternal = require("../app-render/after-task-async-storage.external");
+const _usecachemessages = require("../use-cache/use-cache-messages");
 function throwWithStaticGenerationBailoutErrorWithDynamicError(route, expression) {
-    throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
-        value: "E543",
-        enumerable: false,
-        configurable: true
-    });
+    throw new _staticgenerationbailout.StaticGenBailoutError(`Route ${route} with \`dynamic = "error"\` couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`);
 }
 function throwForSearchParamsAccessInUseCache(workStore, constructorOpt) {
-    const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`searchParams\` inside "use cache". Accessing dynamic request data inside a cache scope is not supported. If you need some search params inside a cached function await \`searchParams\` outside of the cached function and pass only the required search params as arguments to the cached function. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
-        value: "E842",
-        enumerable: false,
-        configurable: true
-    });
+    const error = (0, _usecachemessages.createSearchParamsInUseCacheError)(workStore.route);
     Error.captureStackTrace(error, constructorOpt);
     workStore.invalidDynamicUsageError ??= error;
     throw error;