gsd-pi 2.67.0-dev.46f9884 → 2.67.0-dev.509bd95

package/dist/web/standalone/node_modules/next/dist/server/render.js

@@ -80,7 +80,7 @@ if (process.env.NEXT_RUNTIME !== 'edge') {
 function noRouter() {
     const message = 'No router instance found. you should only use "next/router" inside the client side of your app. https://nextjs.org/docs/messages/no-router-instance';
     throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E1027",
         enumerable: false,
         configurable: true
     });
@@ -209,9 +209,8 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
     (0, _apiutils.setLazyProp)({
         req: req
     }, 'cookies', (0, _getcookieparser.getCookieParser)(req.headers));
-    const metadata = {};
-    metadata.assetQueryString = renderOpts.dev && renderOpts.assetQueryString || '';
-    if (renderOpts.dev && !metadata.assetQueryString) {
+    let baseAssetQueryString = process.env.__NEXT_DEV_SERVER && renderOpts.assetQueryString || '';
+    if (process.env.__NEXT_DEV_SERVER && !baseAssetQueryString) {
         const userAgent = (req.headers['user-agent'] || '').toLowerCase();
         if (userAgent.includes('safari') && !userAgent.includes('chrome')) {
             // In dev we invalidate the cache by appending a timestamp to the resource URL.
@@ -219,18 +218,19 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             // TODO: remove this workaround when https://bugs.webkit.org/show_bug.cgi?id=187726 is fixed.
             // Note: The workaround breaks breakpoints on reload since the script url always changes,
             // so we only apply it to Safari.
-            metadata.assetQueryString = `?ts=${Date.now()}`;
+            baseAssetQueryString = `?ts=${Date.now()}`;
         }
     }
-    // if deploymentId is provided we append it to all asset requests
-    if (sharedContext.deploymentId) {
-        metadata.assetQueryString += `${metadata.assetQueryString ? '&' : '?'}dpl=${sharedContext.deploymentId}`;
-    }
+    const mutableAssetQueryString = baseAssetQueryString + (sharedContext.deploymentId ? `${baseAssetQueryString ? '&' : '?'}dpl=${sharedContext.deploymentId}` : '');
+    const assetQueryString = baseAssetQueryString + (sharedContext.clientAssetToken ? `${baseAssetQueryString ? '&' : '?'}dpl=${sharedContext.clientAssetToken}` : '');
+    const metadata = {
+        assetQueryString,
+        mutableAssetQueryString
+    };
     // don't modify original query object
     query = Object.assign({}, query);
-    const { err, dev = false, pageConfig = {}, buildManifest, reactLoadableManifest, ErrorDebug, getStaticProps, getStaticPaths, getServerSideProps, isNextDataRequest, params, previewProps, basePath, images, runtime: globalRuntime, isExperimentalCompile, expireTime } = renderOpts;
+    const { err, pageConfig = {}, buildManifest, reactLoadableManifest, ErrorDebug, getStaticProps, getStaticPaths, getServerSideProps, isNextDataRequest, params, previewProps, basePath, images, runtime: globalRuntime, isExperimentalCompile, expireTime } = renderOpts;
     const { App } = extra;
-    const assetQueryString = metadata.assetQueryString;
     let Document = extra.Document;
     let Component = renderOpts.Component;
     const OriginComponent = Component;
@@ -239,13 +239,13 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
     // next internal queries should be stripped out
     (0, _internalutils.stripInternalQueries)(query);
     const isSSG = !!getStaticProps;
-    const isBuildTimeSSG = isSSG && renderOpts.nextExport;
+    const isBuildTimeSSG = isSSG && renderOpts.isBuildTimePrerendering;
     const defaultAppGetInitialProps = App.getInitialProps === App.origGetInitialProps;
     const hasPageGetInitialProps = !!(Component == null ? void 0 : Component.getInitialProps);
     const hasPageScripts = Component == null ? void 0 : Component.unstable_scriptLoader;
     const pageIsDynamic = (0, _isdynamic.isDynamicRoute)(pathname);
     const defaultErrorGetInitialProps = pathname === '/_error' && Component.getInitialProps === Component.origGetInitialProps;
-    if (renderOpts.nextExport && hasPageGetInitialProps && !defaultErrorGetInitialProps) {
+    if (renderOpts.isBuildTimePrerendering && hasPageGetInitialProps && !defaultErrorGetInitialProps) {
         warn(`Detected getInitialProps on page '${pathname}'` + ` while running export. It's recommended to use getStaticProps` + ` which has a more correct behavior for static exporting.` + `\nRead more: https://nextjs.org/docs/messages/get-initial-props-export`);
     }
     let isAutoExport = !hasPageGetInitialProps && defaultAppGetInitialProps && !isSSG && !getServerSideProps;
@@ -253,7 +253,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
     // would normally be automatically statically optimized
     // ensure we set cache header so it's not rendered on-demand
     // every request
-    if (isAutoExport && !dev && isExperimentalCompile) {
+    if (isAutoExport && !process.env.__NEXT_DEV_SERVER && isExperimentalCompile) {
         res.setHeader('Cache-Control', (0, _cachecontrol.getCacheControlHeader)({
             revalidate: false,
             expire: expireTime
@@ -310,7 +310,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
         });
     }
     let asPath = renderOpts.resolvedAsPath || req.url;
-    if (dev) {
+    if (process.env.__NEXT_DEV_SERVER) {
         const { isValidElementType } = require('next/dist/compiled/react-is');
         if (!isValidElementType(Component)) {
             throw Object.defineProperty(new Error(`The default export is not a React Component in page: "${pathname}"`), "__NEXT_ERROR_CODE", {
@@ -498,7 +498,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
         }
     };
     let props;
-    const nextExport = !isSSG && (renderOpts.nextExport || dev && (isAutoExport || isFallback));
+    const nextExport = !isSSG && (renderOpts.isBuildTimePrerendering || process.env.__NEXT_DEV_SERVER && (isAutoExport || isFallback));
     const styledJsxInsertedHTML = ()=>{
         const styles = jsxStyleRegistry.styles();
         jsxStyleRegistry.flush();
@@ -611,7 +611,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             }
             metadata.isRedirect = true;
         }
-        if ((dev || isBuildTimeSSG) && !metadata.isNotFound && !(0, _isserializableprops.isSerializableProps)(pathname, 'getStaticProps', data.props)) {
+        if ((process.env.__NEXT_DEV_SERVER || isBuildTimeSSG) && !metadata.isNotFound && !(0, _isserializableprops.isSerializableProps)(pathname, 'getStaticProps', data.props)) {
             // this fn should throw an error instead of ever returning `false`
             throw Object.defineProperty(new Error('invariant: getStaticProps did not return valid props. Please report this.'), "__NEXT_ERROR_CODE", {
                 value: "E129",
@@ -697,7 +697,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
                         const message = `You should not access 'res' after getServerSideProps resolves.` + `\nRead more: https://nextjs.org/docs/messages/gssp-no-mutating-res`;
                         if (deferredContent) {
                             throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                                value: "E394",
+                                value: "E1028",
                                 enumerable: false,
                                 configurable: true
                             });
@@ -815,7 +815,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             ;
             data.props = await data.props;
         }
-        if ((dev || isBuildTimeSSG) && !(0, _isserializableprops.isSerializableProps)(pathname, 'getServerSideProps', data.props)) {
+        if ((process.env.__NEXT_DEV_SERVER || isBuildTimeSSG) && !(0, _isserializableprops.isSerializableProps)(pathname, 'getServerSideProps', data.props)) {
             // this fn should throw an error instead of ever returning `false`
             throw Object.defineProperty(new Error('invariant: getServerSideProps did not return valid props. Please report this.'), "__NEXT_ERROR_CODE", {
                 value: "E31",
@@ -906,7 +906,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
                         head
                     };
                 }
-                if (dev && (props.router || props.Component)) {
+                if (process.env.__NEXT_DEV_SERVER && (props.router || props.Component)) {
                     throw Object.defineProperty(new Error(`'router' and 'Component' can not be returned in getInitialProps from _app.js https://nextjs.org/docs/messages/cant-override-next-props`), "__NEXT_ERROR_CODE", {
                         value: "E230",
                         enumerable: false,
@@ -932,7 +932,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             if (!docProps || typeof docProps.html !== 'string') {
                 const message = `"${(0, _utils.getDisplayName)(Document)}.getInitialProps()" should resolve to an object with a "html" prop set with a valid html string`;
                 throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-                    value: "E394",
+                    value: "E1039",
                     enumerable: false,
                     configurable: true
                 });
@@ -968,26 +968,21 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
         // If it has getInitialProps, we will render the shell in `renderPage`.
         // Otherwise we do it right now.
         let documentInitialPropsRes;
-        const [rawStyledJsxInsertedHTML, content] = await Promise.all([
-            renderToString(styledJsxInsertedHTML()),
-            (async ()=>{
-                if (hasDocumentGetInitialProps) {
-                    documentInitialPropsRes = await loadDocumentInitialProps(renderShell);
-                    if (documentInitialPropsRes === null) return null;
-                    const { docProps } = documentInitialPropsRes;
-                    return docProps.html;
-                } else {
-                    documentInitialPropsRes = {};
-                    const stream = await renderShell(App, Component);
-                    await stream.allReady;
-                    return (0, _nodewebstreamshelper.streamToString)(stream);
-                }
-            })()
-        ]);
-        if (content === null) {
-            return null;
+        let content;
+        if (hasDocumentGetInitialProps) {
+            documentInitialPropsRes = await loadDocumentInitialProps(renderShell);
+            if (documentInitialPropsRes === null) {
+                content = null;
+            } else {
+                const { docProps } = documentInitialPropsRes;
+                content = docProps.html;
+            }
+        } else {
+            documentInitialPropsRes = {};
+            const stream = await renderShell(App, Component);
+            await stream.allReady;
+            content = await (0, _nodewebstreamshelper.streamToString)(stream);
         }
-        const contentHTML = rawStyledJsxInsertedHTML + content;
         // @ts-ignore: documentInitialPropsRes is set
         const { docProps } = documentInitialPropsRes || {};
         const documentElement = (htmlProps)=>{
@@ -1008,6 +1003,12 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             styles = jsxStyleRegistry.styles();
             jsxStyleRegistry.flush();
         }
+        // Registry is now flushed; rawStyledJsxInsertedHTML will be empty.
+        const rawStyledJsxInsertedHTML = await renderToString(styledJsxInsertedHTML());
+        if (content === null) {
+            return null;
+        }
+        const contentHTML = rawStyledJsxInsertedHTML + content;
         return {
             contentHTML,
             documentElement,
@@ -1054,7 +1055,7 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             isFallback,
             isExperimentalCompile,
             dynamicIds: dynamicImportsIds.size === 0 ? undefined : Array.from(dynamicImportsIds),
-            err: renderOpts.err ? serializeError(dev, renderOpts.err) : undefined,
+            err: renderOpts.err ? serializeError(!!process.env.__NEXT_DEV_SERVER, renderOpts.err) : undefined,
             gsp: !!getStaticProps ? true : undefined,
             gssp: !!getServerSideProps ? true : undefined,
             customServer: sharedContext.customServer,
@@ -1065,20 +1066,22 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             defaultLocale,
             domainLocales,
             isPreview: isPreview === true ? true : undefined,
-            notFoundSrcPage: notFoundSrcPage && dev ? notFoundSrcPage : undefined
+            notFoundSrcPage: notFoundSrcPage && process.env.__NEXT_DEV_SERVER ? notFoundSrcPage : undefined
         },
         nonce,
         buildManifest: filteredBuildManifest,
         docComponentsRendered,
         dangerousAsPath: router.asPath,
-        isDevelopment: !!dev,
+        isDevelopment: !!process.env.__NEXT_DEV_SERVER,
+        deploymentId: sharedContext.deploymentId,
         dynamicImports: Array.from(dynamicImports),
         dynamicCssManifest: new Set(renderOpts.dynamicCssManifest || []),
         assetPrefix,
         // Only enabled in production as development mode has features relying on HMR (style injection for example)
         unstable_runtimeJS: process.env.NODE_ENV === 'production' ? pageConfig.unstable_runtimeJS : undefined,
         unstable_JsPreload: pageConfig.unstable_JsPreload,
-        assetQueryString,
+        assetQueryString: assetQueryString || '',
+        mutableAssetQueryString: mutableAssetQueryString || '',
         scriptLoader,
         locale,
         disableOptimizedLoading,

package/dist/web/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/dist/web/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/dist/web/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/dist/web/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/dist/web/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/dist/web/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/dist/web/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;

package/dist/web/standalone/node_modules/next/dist/server/route-modules/app-page/module.js

@@ -28,12 +28,16 @@ _export(exports, {
         return vendored;
     }
 });
+const _requestmeta = require("../../request-meta");
 const _apprender = require("../../app-render/app-render");
 const _routemodule = require("../route-module");
 const _entrypoints = /*#__PURE__*/ _interop_require_wildcard(require("./vendored/contexts/entrypoints"));
 const _prerendermanifestmatcher = require("./helpers/prerender-manifest-matcher");
 const _approuterheaders = require("../../../client/components/app-router-headers");
 const _interceptionroutes = require("../../../shared/lib/router/utils/interception-routes");
+const _rsc = require("../../normalizers/request/rsc");
+const _segmentprefixrsc = require("../../normalizers/request/segment-prefix-rsc");
+const _normalizerequesturl = require("./normalize-request-url");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -98,6 +102,29 @@ class AppPageRouteModule extends _routemodule.RouteModule {
         // Match the pathname to the dynamic route.
         return matcher.match(pathname);
     }
+    normalizeUrl(req, parsedUrl) {
+        if (this.normalizers.segmentPrefetchRSC.match(parsedUrl.pathname || '/')) {
+            const result = this.normalizers.segmentPrefetchRSC.extract(parsedUrl.pathname || '/');
+            if (!result) return false;
+            const { originalPathname, segmentPath } = result;
+            parsedUrl.pathname = originalPathname;
+            // Mark the request as a router prefetch request.
+            req.headers[_approuterheaders.RSC_HEADER] = '1';
+            req.headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = '1';
+            req.headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER] = segmentPath;
+            (0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
+            (0, _requestmeta.addRequestMeta)(req, 'isPrefetchRSCRequest', true);
+            (0, _requestmeta.addRequestMeta)(req, 'segmentPrefetchRSCRequest', segmentPath);
+        } else if (this.normalizers.rsc.match(parsedUrl.pathname || '/')) {
+            parsedUrl.pathname = this.normalizers.rsc.normalize(parsedUrl.pathname || '/', true);
+            // Mark the request as a RSC request.
+            req.headers[_approuterheaders.RSC_HEADER] = '1';
+            (0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
+        } else {
+            super.normalizeUrl(req, parsedUrl);
+        }
+        (0, _normalizerequesturl.normalizeAppPageRequestUrl)(req, parsedUrl.pathname || '/');
+    }
     render(req, res, context) {
         return (0, _apprender.renderToHTMLOrFlight)(req, res, context.page, context.query, context.fallbackRouteParams, context.renderOpts, context.serverComponentsHmrCache, context.sharedContext);
     }
@@ -119,7 +146,10 @@ class AppPageRouteModule extends _routemodule.RouteModule {
         }
     }
     constructor(...args){
-        super(...args), this.matchers = new WeakMap();
+        super(...args), this.matchers = new WeakMap(), this.normalizers = {
+            rsc: new _rsc.RSCPathnameNormalizer(),
+            segmentPrefetchRSC: new _segmentprefixrsc.SegmentPrefixRSCPathnameNormalizer()
+        };
     }
 }
 const vendored = {

package/dist/web/standalone/node_modules/next/dist/server/route-modules/app-page/normalize-request-url.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizeAppPageRequestUrl", {
+    enumerable: true,
+    get: function() {
+        return normalizeAppPageRequestUrl;
+    }
+});
+const _url = require("../../../lib/url");
+const _formaturl = require("../../../shared/lib/router/utils/format-url");
+function normalizeAppPageRequestUrl(req, pathname) {
+    if (!req.url) {
+        return;
+    }
+    const normalizedUrl = (0, _url.parseReqUrl)(req.url);
+    if (!normalizedUrl) {
+        return;
+    }
+    normalizedUrl.pathname = pathname;
+    req.url = (0, _formaturl.formatUrl)(normalizedUrl);
+}
+
+//# sourceMappingURL=normalize-request-url.js.map