@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/client/dev/hot-reloader/pages/hot-reloader-pages.js

@@ -219,6 +219,11 @@ function handleStaticIndicator() {
                 }
                 break;
             }
+        case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.VULNERABILITY_INSIGHT:
+            {
+                _nextdevtools.dispatcher.onVulnerabilityInsight(message.hasVulnerabilityInsight);
+                break;
+            }
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.BUILT:
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SYNC:
             {
@@ -227,6 +232,9 @@ function handleStaticIndicator() {
                 const { errors, warnings } = message;
                 // Is undefined when it's a 'built' event
                 if ('versionInfo' in message) _nextdevtools.dispatcher.onVersionInfo(message.versionInfo);
+                if ('hasVulnerabilityInsight' in message) {
+                    _nextdevtools.dispatcher.onVulnerabilityInsight(message.hasVulnerabilityInsight);
+                }
                 if ('devIndicator' in message) _nextdevtools.dispatcher.onDevIndicator(message.devIndicator);
                 if ('devToolsConfig' in message) _nextdevtools.dispatcher.onDevToolsConfig(message.devToolsConfig);
                 const hasErrors = Boolean(errors && errors.length);
@@ -256,6 +264,9 @@ function handleStaticIndicator() {
             }
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES:
             {
+                for (const listener of turbopackMessageListeners){
+                    listener(message);
+                }
                 turbopackHmr?.onServerComponentChanges();
                 if (hasCompileErrors || _runtimeerrorhandler.RuntimeErrorHandler.hadRuntimeError) {
                     window.location.reload();
@@ -272,11 +283,7 @@ function handleStaticIndicator() {
                 const { errorJSON } = message;
                 if (errorJSON) {
                     const errorObject = JSON.parse(errorJSON);
-                    const error = Object.defineProperty(new Error(errorObject.message), "__NEXT_ERROR_CODE", {
-                        value: "E394",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    const error = new Error(errorObject.message);
                     error.stack = errorObject.stack;
                     handleErrors([
                         error
@@ -301,7 +308,8 @@ function handleStaticIndicator() {
                 for (const listener of turbopackMessageListeners){
                     listener({
                         type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.TURBOPACK_MESSAGE,
-                        data: message.data
+                        data: message.data,
+                        hmrVersion: message.hmrVersion
                     });
                 }
                 if (_runtimeerrorhandler.RuntimeErrorHandler.hadRuntimeError) {
@@ -323,6 +331,7 @@ function handleStaticIndicator() {
             _nextdevtools.dispatcher.onDevToolsConfig(message.data);
             break;
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.CACHE_INDICATOR:
+        case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.RUNTIME_ERRORS:
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REQUEST_INSIGHTS_UPDATE:
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK:
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ERRORS_TO_SHOW_IN_BROWSER:

package/app/node_modules/next/dist/client/dev/hot-reloader/runtime-error-state.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createRuntimeErrorStateReporter: null,
+    reportCurrentRuntimeErrorState: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createRuntimeErrorStateReporter: function() {
+        return createRuntimeErrorStateReporter;
+    },
+    reportCurrentRuntimeErrorState: function() {
+        return reportCurrentRuntimeErrorState;
+    }
+});
+const _nextdevtools = require("next/dist/compiled/next-devtools");
+const _hotreloadertypes = require("../../../server/dev/hot-reloader-types");
+let reportCurrentState = null;
+function reportCurrentRuntimeErrorState() {
+    reportCurrentState?.();
+}
+function createRuntimeErrorStateReporter(sendMessage) {
+    let lastSerializedState = null;
+    const report = (errorState, force = false)=>{
+        const pathname = window.location.pathname;
+        const serializedState = JSON.stringify({
+            pathname,
+            errorState
+        });
+        if (!force && serializedState === lastSerializedState) {
+            return;
+        }
+        lastSerializedState = serializedState;
+        const update = {
+            event: _hotreloadertypes.HMR_MESSAGE_SENT_TO_SERVER.RUNTIME_ERRORS,
+            pathname,
+            errorState
+        };
+        sendMessage(JSON.stringify(update));
+    };
+    (0, _nextdevtools.subscribeToRuntimeErrorState)((state)=>report(state));
+    const reportCurrent = (force)=>{
+        const state = (0, _nextdevtools.getSerializedRuntimeErrorState)();
+        if (state) {
+            report({
+                errors: state.errors,
+                routerType: state.routerType
+            }, force);
+        }
+    };
+    reportCurrentState = ()=>reportCurrent(false);
+    return {
+        reportCurrent () {
+            reportCurrent(true);
+        }
+    };
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=runtime-error-state.js.map

package/app/node_modules/next/dist/client/flight-data-helpers.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     createInitialRSCPayloadFromFallbackPrerender: null,
-    getFlightDataPartsFromPath: null,
     getNextFlightSegmentPath: null,
-    normalizeFlightData: null,
     prepareFlightRouterStateForRequest: null
 });
 function _export(target, all) {
@@ -19,45 +17,15 @@ _export(exports, {
     createInitialRSCPayloadFromFallbackPrerender: function() {
         return createInitialRSCPayloadFromFallbackPrerender;
     },
-    getFlightDataPartsFromPath: function() {
-        return getFlightDataPartsFromPath;
-    },
     getNextFlightSegmentPath: function() {
         return getNextFlightSegmentPath;
     },
-    normalizeFlightData: function() {
-        return normalizeFlightData;
-    },
     prepareFlightRouterStateForRequest: function() {
         return prepareFlightRouterStateForRequest;
     }
 });
-const _segment = require("../shared/lib/segment");
 const _routeparams = require("./route-params");
 const _createhreffromurl = require("./components/router-reducer/create-href-from-url");
-function getFlightDataPartsFromPath(flightDataPath) {
-    // Pick the last 4 items from the `FlightDataPath` to get the [tree, seedData, viewport, isHeadPartial].
-    const flightDataPathLength = 4;
-    // tree, seedData, and head are *always* the last three items in the `FlightDataPath`.
-    const [tree, seedData, head, isHeadPartial] = flightDataPath.slice(-flightDataPathLength);
-    // The `FlightSegmentPath` is everything except the last three items. For a root render, it won't be present.
-    const segmentPath = flightDataPath.slice(0, -flightDataPathLength);
-    return {
-        // TODO: Unify these two segment path helpers. We are inconsistently pushing an empty segment ("")
-        // to the start of the segment path in some places which makes it hard to use solely the segment path.
-        // Look for "// TODO-APP: remove ''" in the codebase.
-        pathToSegment: segmentPath.slice(0, -1),
-        segmentPath,
-        // if the `FlightDataPath` corresponds with the root, there'll be no segment path,
-        // in which case we default to ''.
-        segment: segmentPath[segmentPath.length - 1] ?? '',
-        tree,
-        seedData,
-        head,
-        isHeadPartial,
-        isRootRender: flightDataPath.length === flightDataPathLength
-    };
-}
 function createInitialRSCPayloadFromFallbackPrerender(response, fallbackInitialRSCPayload) {
     // This is a static fallback page. In order to hydrate the page, we need to
     // parse the client params from the URL, but to account for the possibility
@@ -78,95 +46,78 @@ function createInitialRSCPayloadFromFallbackPrerender(response, fallbackInitialR
     // all the different deployment environments we support, like output:
     // "export" mode, where we currently don't assume that custom response
     // headers are present.
-    // Patch the Flight data sent by the server with the correct params parsed
-    // from the URL + response object.
+    // Patch the transport tree sent by the server with the correct params
+    // parsed from the URL + response object.
     const renderedPathname = (0, _routeparams.getRenderedPathname)(response);
     const renderedSearch = (0, _routeparams.getRenderedSearch)(response);
     const canonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(new URL(location.href));
-    const originalFlightDataPath = fallbackInitialRSCPayload.f[0];
-    const originalFlightRouterState = originalFlightDataPath[0];
+    const fallbackTransportData = fallbackInitialRSCPayload.t;
     const payload = {
         c: canonicalUrl.split('/'),
         q: renderedSearch,
         i: fallbackInitialRSCPayload.i,
-        f: [
-            [
-                fillInFallbackFlightRouterState(originalFlightRouterState, renderedPathname, renderedSearch),
-                originalFlightDataPath[1],
-                originalFlightDataPath[2],
-                // isHeadPartial. Previously this incorrectly passed the head itself
-                // (index 2), which is truthy, so the head was always treated
-                // as partial.
-                originalFlightDataPath[3]
-            ]
-        ],
+        t: {
+            t: fillInFallbackTransportTree(fallbackTransportData.t, renderedPathname.split('/').filter((part)=>part !== ''), 0),
+            h: fallbackTransportData.h
+        },
         m: fallbackInitialRSCPayload.m,
         G: fallbackInitialRSCPayload.G,
-        S: fallbackInitialRSCPayload.S,
-        h: fallbackInitialRSCPayload.h
+        S: fallbackInitialRSCPayload.S
     };
     if (fallbackInitialRSCPayload.b) {
         payload.b = fallbackInitialRSCPayload.b;
     }
     return payload;
 }
-function fillInFallbackFlightRouterState(flightRouterState, renderedPathname, renderedSearch) {
-    const pathnameParts = renderedPathname.split('/').filter((p)=>p !== '');
-    const index = 0;
-    return fillInFallbackFlightRouterStateImpl(flightRouterState, renderedSearch, pathnameParts, index);
-}
-function fillInFallbackFlightRouterStateImpl(flightRouterState, renderedSearch, pathnameParts, pathnamePartsIndex) {
-    const originalSegment = flightRouterState[0];
+/**
+ * A fallback prerender is rendered without concrete param values. Fill them
+ * in by parsing the rendered pathname, so the hydrated tree has the same
+ * identity a direct render of this URL would have.
+ */ function fillInFallbackTransportTree(node, pathnameParts, pathnamePartsIndex) {
+    const originalSegment = node.s;
     let newSegment;
     let doesAppearInURL;
     if (typeof originalSegment === 'string') {
         newSegment = originalSegment;
         doesAppearInURL = (0, _routeparams.doesStaticSegmentAppearInURL)(originalSegment);
     } else {
-        const paramName = originalSegment[0];
-        const paramType = originalSegment[2];
-        const staticSiblings = originalSegment[3];
-        const paramValue = (0, _routeparams.parseDynamicParamFromURLPart)(paramType, pathnameParts, pathnamePartsIndex);
-        const cacheKey = (0, _routeparams.getCacheKeyForDynamicParam)(paramValue, renderedSearch);
-        newSegment = [
-            paramName,
-            cacheKey,
-            paramType,
-            staticSiblings
-        ];
+        const paramValue = (0, _routeparams.parseDynamicParamFromURLPart)(originalSegment.t, pathnameParts, pathnamePartsIndex);
+        newSegment = {
+            n: originalSegment.n,
+            t: originalSegment.t,
+            k: (0, _routeparams.getCacheKeyForDynamicParam)(paramValue),
+            s: originalSegment.s
+        };
         doesAppearInURL = true;
     }
     // Only increment the index if the segment appears in the URL. If it's a
     // "virtual" segment, like a route group, it remains the same.
     const childPathnamePartsIndex = doesAppearInURL ? pathnamePartsIndex + 1 : pathnamePartsIndex;
-    const children = flightRouterState[1];
-    const newChildren = {};
-    for(let key in children){
-        const childFlightRouterState = children[key];
-        newChildren[key] = fillInFallbackFlightRouterStateImpl(childFlightRouterState, renderedSearch, pathnameParts, childPathnamePartsIndex);
+    const children = node.c;
+    let newChildren;
+    if (children !== undefined) {
+        newChildren = new Map();
+        for (const [parallelRouteKey, childNode] of children){
+            newChildren.set(parallelRouteKey, fillInFallbackTransportTree(childNode, pathnameParts, childPathnamePartsIndex));
+        }
     }
-    const newState = [
-        newSegment,
-        newChildren,
-        null,
-        flightRouterState[3],
-        flightRouterState[4]
-    ];
-    return newState;
+    const newNode = {
+        s: newSegment,
+        d: node.d
+    };
+    if (node.h !== undefined) {
+        newNode.h = node.h;
+    }
+    if (newChildren !== undefined) {
+        newNode.c = newChildren;
+    }
+    return newNode;
 }
 function getNextFlightSegmentPath(flightSegmentPath) {
     // Since `FlightSegmentPath` is a repeated tuple of `Segment` and `ParallelRouteKey`, we slice off two items
     // to get the next segment path.
     return flightSegmentPath.slice(2);
 }
-function normalizeFlightData(flightData) {
-    // FlightData can be a string when the server didn't respond with a proper flight response,
-    // or when a redirect happens, to signal to the client that it needs to perform an MPA navigation.
-    if (typeof flightData === 'string') {
-        return flightData;
-    }
-    return flightData.map((flightDataPath)=>getFlightDataPartsFromPath(flightDataPath));
-}
 function prepareFlightRouterStateForRequest(flightRouterState, isHmrRefresh) {
     // HMR requests need the complete, unmodified state for proper functionality
     if (isHmrRefresh) {
@@ -199,20 +150,16 @@ function prepareFlightRouterStateForRequest(flightRouterState, isHmrRefresh) {
     if (prefetchHints !== undefined) {
         result[4] = prefetchHints;
     }
-    // Everything else is used only by the client and is not needed for requests.
+    // Leave out the page's search params. They're only used by the client, and
+    // request headers may be forwarded through redirects.
     return result;
 }
 /**
  * Strips client-only data from segments:
- * - Search parameters from __PAGE__ segments
  * - staticSiblings from dynamic segment tuples (only needed for client-side
  *   prefetch reuse decisions)
  */ function stripClientOnlyDataFromSegment(segment) {
     if (typeof segment === 'string') {
-        // Strip search params from __PAGE__ segments
-        if (segment.startsWith(_segment.PAGE_SEGMENT_KEY + '?')) {
-            return _segment.PAGE_SEGMENT_KEY;
-        }
         return segment;
     }
     // Dynamic segment tuple: [paramName, paramCacheKey, paramType, staticSiblings]

package/app/node_modules/next/dist/client/route-loader.js

@@ -92,11 +92,7 @@ function prefetchViaDom(href, as, link) {
         link.rel = `prefetch`;
         link.crossOrigin = process.env.__NEXT_CROSS_ORIGIN;
         link.onload = resolve;
-        link.onerror = ()=>reject(markAssetError(Object.defineProperty(new Error(`Failed to prefetch: ${href}`), "__NEXT_ERROR_CODE", {
-                value: "E268",
-                enumerable: false,
-                configurable: true
-            })));
+        link.onerror = ()=>reject(markAssetError(new Error(`Failed to prefetch: ${href}`)));
         // `href` should always be last:
         link.href = href;
         document.head.appendChild(link);
@@ -109,11 +105,7 @@ function appendScript(src, script) {
         // 1. Setup success/failure hooks in case the browser synchronously
         //    executes when `src` is set.
         script.onload = resolve;
-        script.onerror = ()=>reject(markAssetError(Object.defineProperty(new Error(`Failed to load script: ${src}`), "__NEXT_ERROR_CODE", {
-                value: "E74",
-                enumerable: false,
-                configurable: true
-            })));
+        script.onerror = ()=>reject(markAssetError(new Error(`Failed to load script: ${src}`)));
         // 2. Configure the cross-origin attribute before setting `src` in case the
         //    browser begins to fetch.
         script.crossOrigin = process.env.__NEXT_CROSS_ORIGIN;
@@ -138,11 +130,7 @@ function getClientBuildManifest() {
             cb && cb();
         };
     });
-    return (0, _promise.resolvePromiseWithTimeout)(onBuildManifest, markAssetError(Object.defineProperty(new Error('Failed to load client build manifest'), "__NEXT_ERROR_CODE", {
-        value: "E273",
-        enumerable: false,
-        configurable: true
-    })), devBuildPromise);
+    return (0, _promise.resolvePromiseWithTimeout)(onBuildManifest, markAssetError(new Error('Failed to load client build manifest')), devBuildPromise);
 }
 function getFilesForRoute(assetPrefix, route) {
     if (process.env.NODE_ENV === 'development') {
@@ -157,11 +145,7 @@ function getFilesForRoute(assetPrefix, route) {
     }
     return getClientBuildManifest().then((manifest)=>{
         if (!(route in manifest)) {
-            throw markAssetError(Object.defineProperty(new Error(`Failed to lookup route: ${route}`), "__NEXT_ERROR_CODE", {
-                value: "E446",
-                enumerable: false,
-                configurable: true
-            }));
+            throw markAssetError(new Error(`Failed to lookup route: ${route}`));
         }
         const allFiles = manifest[route].map((entry)=>assetPrefix + '/_next/' + (0, _encodeuripath.encodeURIPath)(entry));
         return {
@@ -218,11 +202,7 @@ function createRouteLoader(assetPrefix) {
             credentials: 'same-origin'
         }).then((res)=>{
             if (!res.ok) {
-                throw Object.defineProperty(new Error(`Failed to load stylesheet: ${href}`), "__NEXT_ERROR_CODE", {
-                    value: "E189",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Failed to load stylesheet: ${href}`);
             }
             return res.text().then((text)=>({
                     href: href,
@@ -285,11 +265,7 @@ function createRouteLoader(assetPrefix) {
                             entrypoint,
                             styles: res[1]
                         }));
-                }), markAssetError(Object.defineProperty(new Error(`Route did not complete loading: ${route}`), "__NEXT_ERROR_CODE", {
-                    value: "E12",
-                    enumerable: false,
-                    configurable: true
-                })), devBuildPromise).then(({ entrypoint, styles })=>{
+                }), markAssetError(new Error(`Route did not complete loading: ${route}`)), devBuildPromise).then(({ entrypoint, styles })=>{
                     const res = Object.assign({
                         styles: styles
                     }, entrypoint);

package/app/node_modules/next/dist/client/route-params.js

@@ -7,8 +7,10 @@ Object.defineProperty(exports, "__esModule", {
     doesStaticSegmentAppearInURL: null,
     getCacheKeyForDynamicParam: null,
     getParamValueFromCacheKey: null,
+    getPathnameFromRequestURL: null,
     getRenderedPathname: null,
     getRenderedSearch: null,
+    normalizeRenderedSearch: null,
     parseDynamicParamFromURLPart: null,
     urlSearchParamsToParsedUrlQuery: null,
     urlToUrlWithoutFlightMarker: null
@@ -32,12 +34,18 @@ _export(exports, {
     getParamValueFromCacheKey: function() {
         return getParamValueFromCacheKey;
     },
+    getPathnameFromRequestURL: function() {
+        return getPathnameFromRequestURL;
+    },
     getRenderedPathname: function() {
         return getRenderedPathname;
     },
     getRenderedSearch: function() {
         return getRenderedSearch;
     },
+    normalizeRenderedSearch: function() {
+        return normalizeRenderedSearch;
+    },
     parseDynamicParamFromURLPart: function() {
         return parseDynamicParamFromURLPart;
     },
@@ -52,18 +60,28 @@ const _segment = require("../shared/lib/segment");
 const _segmentvalueencoding = require("../shared/lib/segment-cache/segment-value-encoding");
 const _approuterheaders = require("./components/app-router-headers");
 const _hasbasepath = require("./has-base-path");
+const _normalizetrailingslash = require("./normalize-trailing-slash");
 const _removebasepath = require("./remove-base-path");
+const _querystring = require("../shared/lib/router/utils/querystring");
+function normalizeRenderedSearch(search) {
+    // The same search params should produce the same string whether they came
+    // from the URL, a rewrite header, or the response (e.g. '+' vs '%20'). Only
+    // used for the rendered search. Request URLs keep their original form,
+    // since middleware and rewrites may depend on it.
+    const query = urlSearchParamsToParsedUrlQuery(new URLSearchParams(search));
+    return (0, _querystring.getRenderedSearch)(query);
+}
 function getRenderedSearch(response) {
     // If the server performed a rewrite, the search params used to render the
     // page will be different from the params in the request URL. In this case,
     // the response will include a header that gives the rewritten search query.
     const rewrittenQuery = response.headers.get(_approuterheaders.NEXT_REWRITTEN_QUERY_HEADER);
     if (rewrittenQuery !== null) {
-        return rewrittenQuery === '' ? '' : '?' + rewrittenQuery;
+        return normalizeRenderedSearch(rewrittenQuery);
     }
     // If the header is not present, there was no rewrite, so we use the search
     // query of the response URL.
-    return urlToUrlWithoutFlightMarker(new URL(response.url)).search;
+    return normalizeRenderedSearch(urlToUrlWithoutFlightMarker(new URL(response.url)).search);
 }
 function getRenderedPathname(response) {
     // If the server performed a rewrite, the pathname used to render the
@@ -76,6 +94,10 @@ function getRenderedPathname(response) {
     const pathname = urlToUrlWithoutFlightMarker(new URL(response.url)).pathname;
     return (0, _hasbasepath.hasBasePath)(pathname) ? (0, _removebasepath.removeBasePath)(pathname) : pathname;
 }
+function getPathnameFromRequestURL(url) {
+    const pathname = url.pathname;
+    return (0, _hasbasepath.hasBasePath)(pathname) ? (0, _removebasepath.removeBasePath)(pathname) : pathname;
+}
 function canonicalizeURLPart(part) {
     try {
         return encodeURIComponent(decodeURIComponent(part));
@@ -168,7 +190,7 @@ function doesStaticSegmentAppearInURL(segment) {
     // Otherwise, we wouldn't need this special case because pages are
     // always leaf nodes.
     // TODO: Investigate why the loader produces these fake page segments.
-    segment.startsWith(_segment.PAGE_SEGMENT_KEY) || // Route groups.
+    segment === _segment.PAGE_SEGMENT_KEY || // Route groups.
     segment[0] === '(' && segment.endsWith(')') || segment === _segment.DEFAULT_SEGMENT_KEY || segment === '/_not-found') {
         return false;
     } else {
@@ -176,16 +198,12 @@ function doesStaticSegmentAppearInURL(segment) {
         return true;
     }
 }
-function getCacheKeyForDynamicParam(paramValue, renderedSearch) {
+function getCacheKeyForDynamicParam(paramValue) {
     // This needs to match the logic in get-dynamic-param.ts, until we're able to
     // unify the various implementations so that these are always computed on
     // the client.
     if (typeof paramValue === 'string') {
-        // TODO: Refactor or remove this helper function to accept a string rather
-        // than the whole segment type. Also we can probably just append the
-        // search string instead of turning it into JSON.
-        const pageSegmentWithSearchParams = (0, _segment.addSearchParamsIfPageSegment)(paramValue, urlSearchParamsToParsedUrlQuery(new URLSearchParams(renderedSearch)));
-        return pageSegmentWithSearchParams;
+        return paramValue;
     } else if (paramValue === null) {
         return '';
     } else {
@@ -198,9 +216,13 @@ function urlToUrlWithoutFlightMarker(url) {
     if (process.env.NODE_ENV === 'production') {
         if (process.env.__NEXT_CONFIG_OUTPUT === 'export' && urlWithoutFlightParameters.pathname.endsWith('.txt')) {
             const { pathname } = urlWithoutFlightParameters;
-            const length = pathname.endsWith('/index.txt') ? 10 : 4;
-            // Slice off `/index.txt` or `.txt` from the end of the pathname
-            urlWithoutFlightParameters.pathname = pathname.slice(0, -length);
+            // Undo the marker appended in `fetchServerResponse`, which is keyed on
+            // whether the requested pathname ended with a slash: `index.txt` for
+            // `/foo/`, `.txt` for `/foo`. Slicing off only `index.txt` keeps that
+            // slash, then `normalizePathTrailingSlash` applies the configured
+            // policy so we don't hand-roll a second one here.
+            const length = pathname.endsWith('/index.txt') ? 9 : 4;
+            urlWithoutFlightParameters.pathname = (0, _normalizetrailingslash.normalizePathTrailingSlash)(pathname.slice(0, -length));
         }
     }
     return urlWithoutFlightParameters;

package/app/node_modules/next/dist/client/router.js

@@ -95,11 +95,7 @@ Object.defineProperty(singletonRouter, 'events', {
 function getRouter() {
     if (!singletonRouter.router) {
         const message = 'No router instance found.\n' + 'You should only use "next/router" on the client side of your app.\n';
-        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
-            value: "E1044",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(message);
     }
     return singletonRouter.router;
 }
@@ -143,11 +139,7 @@ const _default = singletonRouter;
 function useRouter() {
     const router = _react.default.useContext(_routercontextsharedruntime.RouterContext);
     if (!router) {
-        throw Object.defineProperty(new Error('NextRouter was not mounted. https://nextjs.org/docs/messages/next-router-not-mounted'), "__NEXT_ERROR_CODE", {
-            value: "E509",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('NextRouter was not mounted. https://nextjs.org/docs/messages/next-router-not-mounted');
     }
     return router;
 }

package/app/node_modules/next/dist/client/sequential-call-server.js

@@ -0,0 +1,45 @@
+// The sequential implementation of callServer (app-call-server.ts): Server
+// Actions are dispatched into the sequential router action queue. Callers
+// must never import this module directly; they import './app-call-server',
+// which resolves here unless `experimental.concurrentRouterQueue` swaps in
+// './concurrent-call-server' at the bundler level (see
+// create-compiler-aliases.ts and next_import_map.rs).
+//
+// This module must remain free of side effects at module scope: in addition
+// to the browser bundle, a statically-resolved copy may be compiled into the
+// pre-compiled app-page runtime bundles, where the bundler alias cannot
+// reach. Only the browser copy ever runs.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "callServer", {
+    enumerable: true,
+    get: function() {
+        return callServer;
+    }
+});
+const _react = require("react");
+const _routerreducertypes = require("./components/router-reducer/router-reducer-types");
+const _useactionqueue = require("./components/use-action-queue");
+async function callServer(actionId, actionArgs) {
+    return new Promise((resolve, reject)=>{
+        (0, _react.startTransition)(()=>{
+            (0, _useactionqueue.dispatchAppRouterAction)({
+                type: _routerreducertypes.ACTION_SERVER_ACTION,
+                actionId,
+                actionArgs,
+                resolve,
+                reject
+            });
+        });
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=sequential-call-server.js.map