.

node_modules/next/dist/client/components/router-reducer/reducers/committed-state.d.ts

@@ -0,0 +1,3 @@
+import type { FlightRouterState } from '../../../../shared/lib/app-router-types';
+export declare function getLastCommittedTree(): FlightRouterState | null;
+export declare function setLastCommittedTree(tree: FlightRouterState): void;

node_modules/next/dist/client/components/router-reducer/reducers/committed-state.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getLastCommittedTree: null,
+    setLastCommittedTree: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getLastCommittedTree: function() {
+        return getLastCommittedTree;
+    },
+    setLastCommittedTree: function() {
+        return setLastCommittedTree;
+    }
+});
+// The tree from the last state that was committed to the browser history
+// (i.e., the last state for which HistoryUpdater's useInsertionEffect ran).
+// This lets the server-patch reducer distinguish between retrying a
+// navigation that already pushed a history entry vs one whose transition
+// suspended and never committed.
+//
+// Currently only used by the server-patch retry logic, but this module is a
+// stepping stone toward a broader refactor of the navigation queue. The
+// existing AppRouter action queue will eventually be replaced by a more
+// reactive model that explicitly tracks pending vs committed navigation
+// state. This file will likely evolve into (or be subsumed by) that new
+// implementation.
+let lastCommittedTree = null;
+function getLastCommittedTree() {
+    return lastCommittedTree;
+}
+function setLastCommittedTree(tree) {
+    lastCommittedTree = tree;
+}
+
+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=committed-state.js.map

node_modules/next/dist/client/components/router-reducer/reducers/committed-state.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/router-reducer/reducers/committed-state.ts"],"sourcesContent":["import type { FlightRouterState } from '../../../../shared/lib/app-router-types'\n\n// The tree from the last state that was committed to the browser history\n// (i.e., the last state for which HistoryUpdater's useInsertionEffect ran).\n// This lets the server-patch reducer distinguish between retrying a\n// navigation that already pushed a history entry vs one whose transition\n// suspended and never committed.\n//\n// Currently only used by the server-patch retry logic, but this module is a\n// stepping stone toward a broader refactor of the navigation queue. The\n// existing AppRouter action queue will eventually be replaced by a more\n// reactive model that explicitly tracks pending vs committed navigation\n// state. This file will likely evolve into (or be subsumed by) that new\n// implementation.\nlet lastCommittedTree: FlightRouterState | null = null\n\nexport function getLastCommittedTree(): FlightRouterState | null {\n  return lastCommittedTree\n}\n\nexport function setLastCommittedTree(tree: FlightRouterState): void {\n  lastCommittedTree = tree\n}\n"],"names":["getLastCommittedTree","setLastCommittedTree","lastCommittedTree","tree"],"mappings":";;;;;;;;;;;;;;;IAgBgBA,oBAAoB;eAApBA;;IAIAC,oBAAoB;eAApBA;;;AAlBhB,yEAAyE;AACzE,4EAA4E;AAC5E,oEAAoE;AACpE,yEAAyE;AACzE,iCAAiC;AACjC,EAAE;AACF,4EAA4E;AAC5E,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,wEAAwE;AACxE,kBAAkB;AAClB,IAAIC,oBAA8C;AAE3C,SAASF;IACd,OAAOE;AACT;AAEO,SAASD,qBAAqBE,IAAuB;IAC1DD,oBAAoBC;AACtB","ignoreList":[0]}

node_modules/next/dist/client/components/router-reducer/reducers/find-head-in-cache.d.ts

@@ -0,0 +1,2 @@
+import type { FlightRouterState, CacheNode } from '../../../../shared/lib/app-router-types';
+export declare function findHeadInCache(cache: CacheNode, parallelRoutes: FlightRouterState[1]): [CacheNode, string, string] | null;

node_modules/next/dist/client/components/router-reducer/reducers/find-head-in-cache.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findHeadInCache", {
+    enumerable: true,
+    get: function() {
+        return findHeadInCache;
+    }
+});
+const _segment = require("../../../../shared/lib/segment");
+const _createroutercachekey = require("../create-router-cache-key");
+function findHeadInCache(cache, parallelRoutes) {
+    return findHeadInCacheImpl(cache, parallelRoutes, '', '');
+}
+function findHeadInCacheImpl(cache, parallelRoutes, keyPrefix, keyPrefixWithoutSearchParams) {
+    const isLastItem = Object.keys(parallelRoutes).length === 0;
+    if (isLastItem) {
+        // Returns the entire Cache Node of the segment whose head we will render.
+        return [
+            cache,
+            keyPrefix,
+            keyPrefixWithoutSearchParams
+        ];
+    }
+    // First try the 'children' parallel route if it exists
+    // when starting from the "root", this corresponds with the main page component
+    const parallelRoutesKeys = Object.keys(parallelRoutes).filter((key)=>key !== 'children');
+    // if we are at the root, we need to check the children slot first
+    if ('children' in parallelRoutes) {
+        parallelRoutesKeys.unshift('children');
+    }
+    const slots = cache.slots;
+    if (slots !== null) {
+        for (const key of parallelRoutesKeys){
+            const [segment, childParallelRoutes] = parallelRoutes[key];
+            // If the parallel is not matched and using the default segment,
+            // skip searching the head from it.
+            if (segment === _segment.DEFAULT_SEGMENT_KEY) {
+                continue;
+            }
+            const childCacheNode = slots[key];
+            if (!childCacheNode) {
+                continue;
+            }
+            const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
+            const cacheKeyWithoutSearchParams = (0, _createroutercachekey.createRouterCacheKey)(segment, true);
+            const item = findHeadInCacheImpl(childCacheNode, childParallelRoutes, keyPrefix + '/' + cacheKey, keyPrefix + '/' + cacheKeyWithoutSearchParams);
+            if (item) {
+                return item;
+            }
+        }
+    }
+    return null;
+}
+
+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=find-head-in-cache.js.map

node_modules/next/dist/client/components/router-reducer/reducers/find-head-in-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/router-reducer/reducers/find-head-in-cache.ts"],"sourcesContent":["import type {\n  FlightRouterState,\n  CacheNode,\n} from '../../../../shared/lib/app-router-types'\nimport { DEFAULT_SEGMENT_KEY } from '../../../../shared/lib/segment'\nimport { createRouterCacheKey } from '../create-router-cache-key'\n\nexport function findHeadInCache(\n  cache: CacheNode,\n  parallelRoutes: FlightRouterState[1]\n): [CacheNode, string, string] | null {\n  return findHeadInCacheImpl(cache, parallelRoutes, '', '')\n}\n\nfunction findHeadInCacheImpl(\n  cache: CacheNode,\n  parallelRoutes: FlightRouterState[1],\n  keyPrefix: string,\n  keyPrefixWithoutSearchParams: string\n): [CacheNode, string, string] | null {\n  const isLastItem = Object.keys(parallelRoutes).length === 0\n  if (isLastItem) {\n    // Returns the entire Cache Node of the segment whose head we will render.\n    return [cache, keyPrefix, keyPrefixWithoutSearchParams]\n  }\n\n  // First try the 'children' parallel route if it exists\n  // when starting from the \"root\", this corresponds with the main page component\n  const parallelRoutesKeys = Object.keys(parallelRoutes).filter(\n    (key) => key !== 'children'\n  )\n\n  // if we are at the root, we need to check the children slot first\n  if ('children' in parallelRoutes) {\n    parallelRoutesKeys.unshift('children')\n  }\n\n  const slots = cache.slots\n  if (slots !== null) {\n    for (const key of parallelRoutesKeys) {\n      const [segment, childParallelRoutes] = parallelRoutes[key]\n      // If the parallel is not matched and using the default segment,\n      // skip searching the head from it.\n      if (segment === DEFAULT_SEGMENT_KEY) {\n        continue\n      }\n\n      const childCacheNode = slots[key]\n      if (!childCacheNode) {\n        continue\n      }\n\n      const cacheKey = createRouterCacheKey(segment)\n      const cacheKeyWithoutSearchParams = createRouterCacheKey(segment, true)\n\n      const item = findHeadInCacheImpl(\n        childCacheNode,\n        childParallelRoutes,\n        keyPrefix + '/' + cacheKey,\n        keyPrefix + '/' + cacheKeyWithoutSearchParams\n      )\n\n      if (item) {\n        return item\n      }\n    }\n  }\n\n  return null\n}\n"],"names":["findHeadInCache","cache","parallelRoutes","findHeadInCacheImpl","keyPrefix","keyPrefixWithoutSearchParams","isLastItem","Object","keys","length","parallelRoutesKeys","filter","key","unshift","slots","segment","childParallelRoutes","DEFAULT_SEGMENT_KEY","childCacheNode","cacheKey","createRouterCacheKey","cacheKeyWithoutSearchParams","item"],"mappings":";;;;+BAOgBA;;;eAAAA;;;yBAHoB;sCACC;AAE9B,SAASA,gBACdC,KAAgB,EAChBC,cAAoC;IAEpC,OAAOC,oBAAoBF,OAAOC,gBAAgB,IAAI;AACxD;AAEA,SAASC,oBACPF,KAAgB,EAChBC,cAAoC,EACpCE,SAAiB,EACjBC,4BAAoC;IAEpC,MAAMC,aAAaC,OAAOC,IAAI,CAACN,gBAAgBO,MAAM,KAAK;IAC1D,IAAIH,YAAY;QACd,0EAA0E;QAC1E,OAAO;YAACL;YAAOG;YAAWC;SAA6B;IACzD;IAEA,uDAAuD;IACvD,+EAA+E;IAC/E,MAAMK,qBAAqBH,OAAOC,IAAI,CAACN,gBAAgBS,MAAM,CAC3D,CAACC,MAAQA,QAAQ;IAGnB,kEAAkE;IAClE,IAAI,cAAcV,gBAAgB;QAChCQ,mBAAmBG,OAAO,CAAC;IAC7B;IAEA,MAAMC,QAAQb,MAAMa,KAAK;IACzB,IAAIA,UAAU,MAAM;QAClB,KAAK,MAAMF,OAAOF,mBAAoB;YACpC,MAAM,CAACK,SAASC,oBAAoB,GAAGd,cAAc,CAACU,IAAI;YAC1D,gEAAgE;YAChE,mCAAmC;YACnC,IAAIG,YAAYE,4BAAmB,EAAE;gBACnC;YACF;YAEA,MAAMC,iBAAiBJ,KAAK,CAACF,IAAI;YACjC,IAAI,CAACM,gBAAgB;gBACnB;YACF;YAEA,MAAMC,WAAWC,IAAAA,0CAAoB,EAACL;YACtC,MAAMM,8BAA8BD,IAAAA,0CAAoB,EAACL,SAAS;YAElE,MAAMO,OAAOnB,oBACXe,gBACAF,qBACAZ,YAAY,MAAMe,UAClBf,YAAY,MAAMiB;YAGpB,IAAIC,MAAM;gBACR,OAAOA;YACT;QACF;IACF;IAEA,OAAO;AACT","ignoreList":[0]}

node_modules/next/dist/client/components/router-reducer/reducers/has-interception-route-in-current-tree.d.ts

@@ -0,0 +1,2 @@
+import type { FlightRouterState } from '../../../../shared/lib/app-router-types';
+export declare function hasInterceptionRouteInCurrentTree([segment, parallelRoutes,]: FlightRouterState): boolean;

node_modules/next/dist/client/components/router-reducer/reducers/has-interception-route-in-current-tree.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hasInterceptionRouteInCurrentTree", {
+    enumerable: true,
+    get: function() {
+        return hasInterceptionRouteInCurrentTree;
+    }
+});
+const _interceptionroutes = require("../../../../shared/lib/router/utils/interception-routes");
+function hasInterceptionRouteInCurrentTree([segment, parallelRoutes]) {
+    // If we have a dynamic segment, it's marked as an interception route by the presence of the `i` suffix.
+    if (Array.isArray(segment) && (segment[2] === 'di(..)(..)' || segment[2] === 'ci(..)(..)' || segment[2] === 'di(.)' || segment[2] === 'ci(.)' || segment[2] === 'di(..)' || segment[2] === 'ci(..)' || segment[2] === 'di(...)' || segment[2] === 'ci(...)')) {
+        return true;
+    }
+    // If segment is not an array, apply the existing string-based check
+    if (typeof segment === 'string' && (0, _interceptionroutes.isInterceptionRouteAppPath)(segment)) {
+        return true;
+    }
+    // Iterate through parallelRoutes if they exist
+    if (parallelRoutes) {
+        for(const key in parallelRoutes){
+            if (hasInterceptionRouteInCurrentTree(parallelRoutes[key])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+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=has-interception-route-in-current-tree.js.map

node_modules/next/dist/client/components/router-reducer/reducers/has-interception-route-in-current-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/router-reducer/reducers/has-interception-route-in-current-tree.ts"],"sourcesContent":["import type { FlightRouterState } from '../../../../shared/lib/app-router-types'\nimport { isInterceptionRouteAppPath } from '../../../../shared/lib/router/utils/interception-routes'\n\nexport function hasInterceptionRouteInCurrentTree([\n  segment,\n  parallelRoutes,\n]: FlightRouterState): boolean {\n  // If we have a dynamic segment, it's marked as an interception route by the presence of the `i` suffix.\n  if (\n    Array.isArray(segment) &&\n    (segment[2] === 'di(..)(..)' ||\n      segment[2] === 'ci(..)(..)' ||\n      segment[2] === 'di(.)' ||\n      segment[2] === 'ci(.)' ||\n      segment[2] === 'di(..)' ||\n      segment[2] === 'ci(..)' ||\n      segment[2] === 'di(...)' ||\n      segment[2] === 'ci(...)')\n  ) {\n    return true\n  }\n\n  // If segment is not an array, apply the existing string-based check\n  if (typeof segment === 'string' && isInterceptionRouteAppPath(segment)) {\n    return true\n  }\n\n  // Iterate through parallelRoutes if they exist\n  if (parallelRoutes) {\n    for (const key in parallelRoutes) {\n      if (hasInterceptionRouteInCurrentTree(parallelRoutes[key])) {\n        return true\n      }\n    }\n  }\n\n  return false\n}\n"],"names":["hasInterceptionRouteInCurrentTree","segment","parallelRoutes","Array","isArray","isInterceptionRouteAppPath","key"],"mappings":";;;;+BAGgBA;;;eAAAA;;;oCAF2B;AAEpC,SAASA,kCAAkC,CAChDC,SACAC,eACkB;IAClB,wGAAwG;IACxG,IACEC,MAAMC,OAAO,CAACH,YACbA,CAAAA,OAAO,CAAC,EAAE,KAAK,gBACdA,OAAO,CAAC,EAAE,KAAK,gBACfA,OAAO,CAAC,EAAE,KAAK,WACfA,OAAO,CAAC,EAAE,KAAK,WACfA,OAAO,CAAC,EAAE,KAAK,YACfA,OAAO,CAAC,EAAE,KAAK,YACfA,OAAO,CAAC,EAAE,KAAK,aACfA,OAAO,CAAC,EAAE,KAAK,SAAQ,GACzB;QACA,OAAO;IACT;IAEA,oEAAoE;IACpE,IAAI,OAAOA,YAAY,YAAYI,IAAAA,8CAA0B,EAACJ,UAAU;QACtE,OAAO;IACT;IAEA,+CAA+C;IAC/C,IAAIC,gBAAgB;QAClB,IAAK,MAAMI,OAAOJ,eAAgB;YAChC,IAAIF,kCAAkCE,cAAc,CAACI,IAAI,GAAG;gBAC1D,OAAO;YACT;QACF;IACF;IAEA,OAAO;AACT","ignoreList":[0]}

node_modules/next/dist/client/components/router-reducer/reducers/hmr-refresh-reducer.d.ts

@@ -0,0 +1,2 @@
+import type { ReadonlyReducerState, ReducerState } from '../router-reducer-types';
+export declare function hmrRefreshReducer(state: ReadonlyReducerState): ReducerState;

node_modules/next/dist/client/components/router-reducer/reducers/hmr-refresh-reducer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "hmrRefreshReducer", {
+    enumerable: true,
+    get: function() {
+        return hmrRefreshReducer;
+    }
+});
+const _refreshreducer = require("./refresh-reducer");
+const _pprnavigations = require("../ppr-navigations");
+function hmrRefreshReducer(state) {
+    return (0, _refreshreducer.refreshDynamicData)(state, _pprnavigations.FreshnessPolicy.HMRRefresh);
+}
+
+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=hmr-refresh-reducer.js.map

node_modules/next/dist/client/components/router-reducer/reducers/hmr-refresh-reducer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/router-reducer/reducers/hmr-refresh-reducer.ts"],"sourcesContent":["import type {\n  ReadonlyReducerState,\n  ReducerState,\n} from '../router-reducer-types'\nimport { refreshDynamicData } from './refresh-reducer'\nimport { FreshnessPolicy } from '../ppr-navigations'\n\nexport function hmrRefreshReducer(state: ReadonlyReducerState): ReducerState {\n  return refreshDynamicData(state, FreshnessPolicy.HMRRefresh)\n}\n"],"names":["hmrRefreshReducer","state","refreshDynamicData","FreshnessPolicy","HMRRefresh"],"mappings":";;;;+BAOgBA;;;eAAAA;;;gCAHmB;gCACH;AAEzB,SAASA,kBAAkBC,KAA2B;IAC3D,OAAOC,IAAAA,kCAAkB,EAACD,OAAOE,+BAAe,CAACC,UAAU;AAC7D","ignoreList":[0]}

node_modules/next/dist/client/components/router-reducer/reducers/navigate-reducer.d.ts

@@ -0,0 +1,4 @@
+import type { NavigateAction, ReadonlyReducerState, ReducerState } from '../router-reducer-types';
+export declare const DYNAMIC_STALETIME_MS: number;
+export declare const STATIC_STALETIME_MS: number;
+export declare function navigateReducer(state: ReadonlyReducerState, action: NavigateAction): ReducerState;

node_modules/next/dist/client/components/router-reducer/reducers/navigate-reducer.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DYNAMIC_STALETIME_MS: null,
+    STATIC_STALETIME_MS: null,
+    navigateReducer: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DYNAMIC_STALETIME_MS: function() {
+        return DYNAMIC_STALETIME_MS;
+    },
+    STATIC_STALETIME_MS: function() {
+        return STATIC_STALETIME_MS;
+    },
+    navigateReducer: function() {
+        return navigateReducer;
+    }
+});
+const _navigation = require("../../segment-cache/navigation");
+const _cache = require("../../segment-cache/cache");
+const _pprnavigations = require("../ppr-navigations");
+const DYNAMIC_STALETIME_MS = Number(process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME) * 1000;
+const STATIC_STALETIME_MS = (0, _cache.getStaleTimeMs)(Number(process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME));
+function navigateReducer(state, action) {
+    const { url, isExternalUrl, navigateType, scrollBehavior } = action;
+    if (isExternalUrl) {
+        return (0, _navigation.completeHardNavigation)(state, url, navigateType);
+    }
+    // Handles case where `<meta http-equiv="refresh">` tag is present,
+    // which will trigger an MPA navigation.
+    if (document.getElementById('__next-page-redirect')) {
+        return (0, _navigation.completeHardNavigation)(state, url, navigateType);
+    }
+    // Temporary glue code between the router reducer and the new navigation
+    // implementation. Eventually we'll rewrite the router reducer to a
+    // state machine.
+    const currentUrl = new URL(state.canonicalUrl, location.origin);
+    const currentRenderedSearch = state.renderedSearch;
+    return (0, _navigation.navigate)(state, url, currentUrl, currentRenderedSearch, state.cache, state.tree, state.nextUrl, _pprnavigations.FreshnessPolicy.Default, scrollBehavior, navigateType);
+}
+
+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=navigate-reducer.js.map

node_modules/next/dist/client/components/router-reducer/reducers/navigate-reducer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/router-reducer/reducers/navigate-reducer.ts"],"sourcesContent":["import type {\n  NavigateAction,\n  ReadonlyReducerState,\n  ReducerState,\n} from '../router-reducer-types'\n\nimport {\n  completeHardNavigation,\n  navigate as navigateUsingSegmentCache,\n} from '../../segment-cache/navigation'\nimport { getStaleTimeMs } from '../../segment-cache/cache'\nimport { FreshnessPolicy } from '../ppr-navigations'\n\n// These values are set by `define-env-plugin` (based on `nextConfig.experimental.staleTimes`)\n// and default to 5 minutes (static) / 0 seconds (dynamic)\nexport const DYNAMIC_STALETIME_MS =\n  Number(process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME) * 1000\n\nexport const STATIC_STALETIME_MS = getStaleTimeMs(\n  Number(process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME)\n)\n\nexport function navigateReducer(\n  state: ReadonlyReducerState,\n  action: NavigateAction\n): ReducerState {\n  const { url, isExternalUrl, navigateType, scrollBehavior } = action\n\n  if (isExternalUrl) {\n    return completeHardNavigation(state, url, navigateType)\n  }\n\n  // Handles case where `<meta http-equiv=\"refresh\">` tag is present,\n  // which will trigger an MPA navigation.\n  if (document.getElementById('__next-page-redirect')) {\n    return completeHardNavigation(state, url, navigateType)\n  }\n\n  // Temporary glue code between the router reducer and the new navigation\n  // implementation. Eventually we'll rewrite the router reducer to a\n  // state machine.\n  const currentUrl = new URL(state.canonicalUrl, location.origin)\n  const currentRenderedSearch = state.renderedSearch\n  return navigateUsingSegmentCache(\n    state,\n    url,\n    currentUrl,\n    currentRenderedSearch,\n    state.cache,\n    state.tree,\n    state.nextUrl,\n    FreshnessPolicy.Default,\n    scrollBehavior,\n    navigateType\n  )\n}\n"],"names":["DYNAMIC_STALETIME_MS","STATIC_STALETIME_MS","navigateReducer","Number","process","env","__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME","getStaleTimeMs","__NEXT_CLIENT_ROUTER_STATIC_STALETIME","state","action","url","isExternalUrl","navigateType","scrollBehavior","completeHardNavigation","document","getElementById","currentUrl","URL","canonicalUrl","location","origin","currentRenderedSearch","renderedSearch","navigateUsingSegmentCache","cache","tree","nextUrl","FreshnessPolicy","Default"],"mappings":";;;;;;;;;;;;;;;;IAeaA,oBAAoB;eAApBA;;IAGAC,mBAAmB;eAAnBA;;IAIGC,eAAe;eAAfA;;;4BAbT;uBACwB;gCACC;AAIzB,MAAMF,uBACXG,OAAOC,QAAQC,GAAG,CAACC,sCAAsC,IAAI;AAExD,MAAML,sBAAsBM,IAAAA,qBAAc,EAC/CJ,OAAOC,QAAQC,GAAG,CAACG,qCAAqC;AAGnD,SAASN,gBACdO,KAA2B,EAC3BC,MAAsB;IAEtB,MAAM,EAAEC,GAAG,EAAEC,aAAa,EAAEC,YAAY,EAAEC,cAAc,EAAE,GAAGJ;IAE7D,IAAIE,eAAe;QACjB,OAAOG,IAAAA,kCAAsB,EAACN,OAAOE,KAAKE;IAC5C;IAEA,mEAAmE;IACnE,wCAAwC;IACxC,IAAIG,SAASC,cAAc,CAAC,yBAAyB;QACnD,OAAOF,IAAAA,kCAAsB,EAACN,OAAOE,KAAKE;IAC5C;IAEA,wEAAwE;IACxE,mEAAmE;IACnE,iBAAiB;IACjB,MAAMK,aAAa,IAAIC,IAAIV,MAAMW,YAAY,EAAEC,SAASC,MAAM;IAC9D,MAAMC,wBAAwBd,MAAMe,cAAc;IAClD,OAAOC,IAAAA,oBAAyB,EAC9BhB,OACAE,KACAO,YACAK,uBACAd,MAAMiB,KAAK,EACXjB,MAAMkB,IAAI,EACVlB,MAAMmB,OAAO,EACbC,+BAAe,CAACC,OAAO,EACvBhB,gBACAD;AAEJ","ignoreList":[0]}

node_modules/next/dist/client/components/router-reducer/reducers/refresh-reducer.d.ts

@@ -0,0 +1,4 @@
+import type { ReadonlyReducerState, ReducerState, RefreshAction } from '../router-reducer-types';
+import { FreshnessPolicy } from '../ppr-navigations';
+export declare function refreshReducer(state: ReadonlyReducerState, action: RefreshAction): ReducerState;
+export declare function refreshDynamicData(state: ReadonlyReducerState, freshnessPolicy: FreshnessPolicy.RefreshAll | FreshnessPolicy.HMRRefresh): ReducerState;

node_modules/next/dist/client/components/router-reducer/reducers/refresh-reducer.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    refreshDynamicData: null,
+    refreshReducer: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    refreshDynamicData: function() {
+        return refreshDynamicData;
+    },
+    refreshReducer: function() {
+        return refreshReducer;
+    }
+});
+const _routerreducertypes = require("../router-reducer-types");
+const _navigation = require("../../segment-cache/navigation");
+const _cache = require("../../segment-cache/cache");
+const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
+const _pprnavigations = require("../ppr-navigations");
+const _bfcache = require("../../segment-cache/bfcache");
+function refreshReducer(state, action) {
+    // During a refresh, we invalidate the segment cache but not the route cache.
+    // The route cache contains the tree structure (which segments exist at a
+    // given URL) which doesn't change during a refresh. The segment cache
+    // contains the actual RSC data which needs to be re-fetched.
+    //
+    // The Instant Navigation Testing API can bypass cache invalidation to
+    // preserve prefetched data when refreshing after an MPA navigation. This is
+    // only used for testing and is not exposed in production builds by default.
+    const bypassCacheInvalidation = process.env.__NEXT_EXPOSE_TESTING_API && action.bypassCacheInvalidation;
+    if (!bypassCacheInvalidation) {
+        const currentNextUrl = state.nextUrl;
+        const currentRouterState = state.tree;
+        (0, _cache.invalidateSegmentCacheEntries)(currentNextUrl, currentRouterState);
+    }
+    return refreshDynamicData(state, _pprnavigations.FreshnessPolicy.RefreshAll);
+}
+function refreshDynamicData(state, freshnessPolicy) {
+    // During a refresh, invalidate the BFCache, which may contain dynamic data.
+    (0, _bfcache.invalidateBfCache)();
+    const currentNextUrl = state.nextUrl;
+    // We always send the last next-url, not the current when performing a dynamic
+    // request. This is because we update the next-url after a navigation, but we
+    // want the same interception route to be matched that used the last next-url.
+    const nextUrlForRefresh = (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree) ? state.previousNextUrl || currentNextUrl : null;
+    // A refresh is modeled as a navigation to the current URL, but where any
+    // existing dynamic data (including in shared layouts) is re-fetched.
+    const currentCanonicalUrl = state.canonicalUrl;
+    const currentUrl = new URL(currentCanonicalUrl, location.origin);
+    const currentRenderedSearch = state.renderedSearch;
+    const currentFlightRouterState = state.tree;
+    const scrollBehavior = _routerreducertypes.ScrollBehavior.NoScroll;
+    // Create a NavigationSeed from the current FlightRouterState.
+    // TODO: Eventually we will store this type directly on the state object
+    // instead of reconstructing it on demand. Part of a larger series of
+    // refactors to unify the various tree types that the client deals with.
+    const now = Date.now();
+    // TODO: Store the dynamic stale time on the top-level state so it's known
+    // during restores and refreshes.
+    const refreshSeed = (0, _navigation.convertServerPatchToFullTree)(now, currentFlightRouterState, null, currentRenderedSearch, _bfcache.UnknownDynamicStaleTime);
+    const navigateType = 'replace';
+    return (0, _navigation.navigateToKnownRoute)(now, state, currentUrl, currentCanonicalUrl, refreshSeed, currentUrl, currentRenderedSearch, state.cache, currentFlightRouterState, freshnessPolicy, nextUrlForRefresh, scrollBehavior, navigateType, null, // Refresh navigations don't use route prediction, so there's no route
+    // cache entry to mark as having a dynamic rewrite on mismatch. If a
+    // mismatch occurs, the retry handler will traverse the known route tree
+    // to find and mark the entry.
+    null);
+}
+
+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=refresh-reducer.js.map

node_modules/next/dist/client/components/router-reducer/reducers/restore-reducer.d.ts

@@ -0,0 +1,2 @@
+import type { ReadonlyReducerState, ReducerState, RestoreAction } from '../router-reducer-types';
+export declare function restoreReducer(state: ReadonlyReducerState, action: RestoreAction): ReducerState;

node_modules/next/dist/client/components/router-reducer/reducers/restore-reducer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "restoreReducer", {
+    enumerable: true,
+    get: function() {
+        return restoreReducer;
+    }
+});
+const _computechangedpath = require("../compute-changed-path");
+const _pprnavigations = require("../ppr-navigations");
+const _navigation = require("../../segment-cache/navigation");
+const _bfcache = require("../../segment-cache/bfcache");
+function restoreReducer(state, action) {
+    // This action is used to restore the router state from the history state.
+    // However, it's possible that the history state no longer contains the `FlightRouterState`.
+    // We will copy over the internal state on pushState/replaceState events, but if a history entry
+    // occurred before hydration, or if the user navigated to a hash using a regular anchor link,
+    // the history state will not contain the `FlightRouterState`.
+    // In this case, we'll continue to use the existing tree so the router doesn't get into an invalid state.
+    let treeToRestore;
+    let renderedSearch;
+    const historyState = action.historyState;
+    if (historyState) {
+        treeToRestore = historyState.tree;
+        renderedSearch = historyState.renderedSearch;
+    } else {
+        treeToRestore = state.tree;
+        renderedSearch = state.renderedSearch;
+    }
+    const currentUrl = new URL(state.canonicalUrl, location.origin);
+    const restoredUrl = action.url;
+    const restoredNextUrl = (0, _computechangedpath.extractPathFromFlightRouterState)(treeToRestore) ?? restoredUrl.pathname;
+    const now = Date.now();
+    // TODO: Store the dynamic stale time on the top-level state so it's known
+    // during restores and refreshes.
+    const accumulation = {
+        separateRefreshUrls: null,
+        scrollRef: null
+    };
+    const restoreSeed = (0, _navigation.convertServerPatchToFullTree)(now, treeToRestore, null, renderedSearch, _bfcache.UnknownDynamicStaleTime);
+    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, state.renderedSearch, state.cache, state.tree, restoreSeed.routeTree, restoreSeed.metadataVaryPath, _pprnavigations.FreshnessPolicy.HistoryTraversal, null, null, restoreSeed.dynamicStaleAt, false, accumulation);
+    if (task === null) {
+        return (0, _navigation.completeHardNavigation)(state, restoredUrl, 'replace');
+    }
+    (0, _pprnavigations.spawnDynamicRequests)(task, restoredUrl, restoredNextUrl, _pprnavigations.FreshnessPolicy.HistoryTraversal, accumulation, // History traversal doesn't use route prediction, so there's no route
+    // cache entry to mark as having a dynamic rewrite on mismatch. If a
+    // mismatch occurs, the retry handler will traverse the known route tree
+    // to find and mark the entry.
+    null, // History traversal always uses 'replace'.
+    'replace');
+    return (0, _navigation.completeTraverseNavigation)(state, restoredUrl, renderedSearch, task.node, task.route, restoredNextUrl);
+}
+
+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=restore-reducer.js.map

node_modules/next/dist/client/components/router-reducer/reducers/server-action-reducer.d.ts

@@ -0,0 +1,2 @@
+import type { ReadonlyReducerState, ReducerState, ServerActionAction } from '../router-reducer-types';
+export declare function serverActionReducer(state: ReadonlyReducerState, action: ServerActionAction): ReducerState;

node_modules/next/dist/client/components/router-reducer/reducers/server-action-reducer.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serverActionReducer", {
+    enumerable: true,
+    get: function() {
+        return serverActionReducer;
+    }
+});
+const _appcallserver = require("../../../app-call-server");
+const _appfindsourcemapurl = require("../../../app-find-source-map-url");
+const _approuterheaders = require("../../app-router-headers");
+const _unrecognizedactionerror = require("../../unrecognized-action-error");
+const _client = require("react-server-dom-webpack/client");
+const _routerreducertypes = require("../router-reducer-types");
+const _assignlocation = require("../../../assign-location");
+const _createhreffromurl = require("../create-href-from-url");
+const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
+const _flightdatahelpers = require("../../../flight-data-helpers");
+const _redirect = require("../../redirect");
+const _removebasepath = require("../../../remove-base-path");
+const _hasbasepath = require("../../../has-base-path");
+const _serverreferenceinfo = require("../../../../shared/lib/server-reference-info");
+const _cache = require("../../segment-cache/cache");
+const _scheduler = require("../../segment-cache/scheduler");
+const _deploymentid = require("../../../../shared/lib/deployment-id");
+const _navigationbuildid = require("../../../navigation-build-id");
+const _constants = require("../../../../lib/constants");
+const _navigation = require("../../segment-cache/navigation");
+const _optimisticroutes = require("../../segment-cache/optimistic-routes");
+const _actionrevalidationkind = require("../../../../shared/lib/action-revalidation-kind");
+const _approuterutils = require("../../app-router-utils");
+const _pprnavigations = require("../ppr-navigations");
+const _fetchserverresponse = require("../fetch-server-response");
+const _bfcache = require("../../segment-cache/bfcache");
+const createFromFetch = _client.createFromFetch;
+let createDebugChannel;
+if (process.env.__NEXT_DEV_SERVER && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
+    createDebugChannel = require('../../../dev/debug-channel').createDebugChannel;
+}
+async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
+    const temporaryReferences = (0, _client.createTemporaryReferenceSet)();
+    const info = (0, _serverreferenceinfo.extractInfoFromServerReferenceId)(actionId);
+    const usedArgs = (0, _serverreferenceinfo.omitUnusedArgs)(actionArgs, info);
+    const body = await (0, _client.encodeReply)(usedArgs, {
+        temporaryReferences
+    });
+    const headers = {
+        Accept: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
+        [_approuterheaders.ACTION_HEADER]: actionId,
+        [_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]: (0, _flightdatahelpers.prepareFlightRouterStateForRequest)(state.tree)
+    };
+    const deploymentId = (0, _deploymentid.getDeploymentId)();
+    if (deploymentId) {
+        headers['x-deployment-id'] = deploymentId;
+    }
+    if (nextUrl) {
+        headers[_approuterheaders.NEXT_URL] = nextUrl;
+    }
+    if (process.env.__NEXT_DEV_SERVER) {
+        if (self.__next_r) {
+            headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] = self.__next_r;
+        }
+        // Create a new request ID for the server action request. The server uses
+        // this to tag debug information sent via WebSocket to the client, which
+        // then routes those chunks to the debug channel associated with this ID.
+        headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] = crypto.getRandomValues(new Uint32Array(1))[0].toString(16);
+    }
+    const res = await fetch(state.canonicalUrl, {
+        method: 'POST',
+        headers,
+        body
+    });
+    // Handle server actions that the server didn't recognize.
+    const unrecognizedActionHeader = res.headers.get(_approuterheaders.NEXT_ACTION_NOT_FOUND_HEADER);
+    if (unrecognizedActionHeader === '1') {
+        throw Object.defineProperty(new _unrecognizedactionerror.UnrecognizedActionError(`Server Action "${actionId}" was not found on the server. \nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
+            value: "E715",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const redirectHeader = res.headers.get('x-action-redirect');
+    const [location1, _redirectType] = redirectHeader?.split(';') || [];
+    let redirectType;
+    switch(_redirectType){
+        case 'push':
+            redirectType = 'push';
+            break;
+        case 'replace':
+            redirectType = 'replace';
+            break;
+        default:
+            redirectType = undefined;
+    }
+    const isPrerender = !!res.headers.get(_approuterheaders.NEXT_IS_PRERENDER_HEADER);
+    let revalidationKind = _actionrevalidationkind.ActionDidNotRevalidate;
+    try {
+        const revalidationHeader = res.headers.get('x-action-revalidated');
+        if (revalidationHeader) {
+            const parsedKind = JSON.parse(revalidationHeader);
+            if (parsedKind === _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic || parsedKind === _actionrevalidationkind.ActionDidRevalidateDynamicOnly) {
+                revalidationKind = parsedKind;
+            }
+        }
+    } catch  {}
+    const redirectLocation = location1 ? (0, _assignlocation.assignLocation)(location1, new URL(state.canonicalUrl, window.location.href)) : undefined;
+    const contentType = res.headers.get('content-type');
+    const isRscResponse = !!(contentType && contentType.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER));
+    // Handle invalid server action responses.
+    // A valid response must have `content-type: text/x-component`, unless it's an external redirect.
+    // (external redirects have an 'x-action-redirect' header, but the body is an empty 'text/plain')
+    if (!isRscResponse && !redirectLocation) {
+        // The server can respond with a text/plain error message, but we'll fallback to something generic
+        // if there isn't one.
+        const message = res.status >= 400 && contentType === 'text/plain' ? await res.text() : 'An unexpected response was received from the server.';
+        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    let actionResult;
+    let actionFlightData;
+    let actionFlightDataRenderedSearch;
+    let couldBeIntercepted = false;
+    if (isRscResponse) {
+        // Server action redirect responses carry the Flight data of the redirect
+        // target, which may be prerendered with a completeness marker byte
+        // prepended. Strip it before passing to Flight.
+        const responsePromise = redirectLocation ? (0, _fetchserverresponse.processFetch)(res).then(({ response: r })=>r) : Promise.resolve(res);
+        const response = await createFromFetch(responsePromise, {
+            callServer: _appcallserver.callServer,
+            findSourceMapURL: _appfindsourcemapurl.findSourceMapURL,
+            temporaryReferences,
+            debugChannel: createDebugChannel && createDebugChannel(headers)
+        });
+        // An internal redirect can send an RSC response, but does not have a useful `actionResult`.
+        actionResult = redirectLocation ? undefined : response.a;
+        couldBeIntercepted = response.i;
+        // Check if the response build ID matches the client build ID.
+        // In a multi-zone setup, when a server action triggers a redirect,
+        // the server pre-fetches the redirect target as RSC. If the redirect
+        // target is served by a different Next.js zone (different build), the
+        // pre-fetched RSC data will have a foreign build ID. We must discard
+        // the flight data in that case so the redirect triggers an MPA
+        // navigation (full page load) instead of trying to apply the foreign
+        // RSC payload — which would result in a blank page.
+        const responseBuildId = res.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? response.b;
+        if (responseBuildId !== undefined && responseBuildId !== (0, _navigationbuildid.getNavigationBuildId)()) {
+        // Build ID mismatch — discard the flight data. The redirect will
+        // still be processed, and the absence of flight data will cause an
+        // MPA navigation via completeHardNavigation().
+        } else {
+            const maybeFlightData = (0, _flightdatahelpers.normalizeFlightData)(response.f);
+            if (maybeFlightData !== '') {
+                actionFlightData = maybeFlightData;
+                actionFlightDataRenderedSearch = response.q;
+            }
+        }
+    } else {
+        // An external redirect doesn't contain RSC data.
+        actionResult = undefined;
+        actionFlightData = undefined;
+        actionFlightDataRenderedSearch = undefined;
+    }
+    return {
+        actionResult,
+        actionFlightData,
+        actionFlightDataRenderedSearch,
+        redirectLocation,
+        redirectType,
+        revalidationKind,
+        isPrerender,
+        couldBeIntercepted
+    };
+}
+function serverActionReducer(state, action) {
+    const { resolve, reject } = action;
+    // only pass along the `nextUrl` param (used for interception routes) if the current route was intercepted.
+    // If the route has been intercepted, the action should be as well.
+    // Otherwise the server action might be intercepted with the wrong action id
+    // (ie, one that corresponds with the intercepted route)
+    const nextUrl = // We always send the last next-url, not the current when
+    // performing a dynamic request. This is because we update
+    // the next-url after a navigation, but we want the same
+    // interception route to be matched that used the last
+    // next-url.
+    (state.previousNextUrl || state.nextUrl) && (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree) ? state.previousNextUrl || state.nextUrl : null;
+    return fetchServerAction(state, nextUrl, action).then(async ({ revalidationKind, actionResult, actionFlightData: flightData, actionFlightDataRenderedSearch: flightDataRenderedSearch, redirectLocation, redirectType, isPrerender, couldBeIntercepted })=>{
+        if (revalidationKind !== _actionrevalidationkind.ActionDidNotRevalidate) {
+            // There was either a revalidation or a refresh, or maybe both.
+            // Evict the BFCache, which may contain dynamic data.
+            (0, _bfcache.invalidateBfCache)();
+            // Store whether this action triggered any revalidation
+            // The action queue will use this information to potentially
+            // trigger a refresh action if the action was discarded
+            // (ie, due to a navigation, before the action completed)
+            action.didRevalidate = true;
+            // If there was a revalidation, evict the prefetch cache.
+            // TODO: Evict only segments with matching tags and/or paths.
+            // TODO: We should only invalidate the route cache if cookies were
+            // mutated, since route trees may vary based on cookies. For now we
+            // invalidate both caches until we have a way to detect cookie
+            // mutations on the client.
+            if (revalidationKind === _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic) {
+                (0, _cache.invalidateEntirePrefetchCache)(nextUrl, state.tree);
+            }
+            // Start a cooldown before re-prefetching to allow CDN cache
+            // propagation.
+            (0, _scheduler.startRevalidationCooldown)();
+        }
+        const navigateType = redirectType || 'push';
+        if (redirectLocation !== undefined) {
+            // If the action triggered a redirect, the action promise will be rejected with
+            // a redirect so that it's handled by RedirectBoundary as we won't have a valid
+            // action result to resolve the promise with. This will effectively reset the state of
+            // the component that called the action as the error boundary will remount the tree.
+            // The status code doesn't matter here as the action handler will have already sent
+            // a response with the correct status code.
+            if ((0, _approuterutils.isExternalURL)(redirectLocation)) {
+                // External redirect. Triggers an MPA navigation.
+                const redirectHref = redirectLocation.href;
+                const redirectError = createRedirectErrorForAction(redirectHref, navigateType);
+                reject(redirectError);
+                return (0, _navigation.completeHardNavigation)(state, redirectLocation, navigateType);
+            } else {
+                // Internal redirect. Triggers an SPA navigation.
+                const redirectWithBasepath = (0, _createhreffromurl.createHrefFromUrl)(redirectLocation, false);
+                const redirectHref = (0, _hasbasepath.hasBasePath)(redirectWithBasepath) ? (0, _removebasepath.removeBasePath)(redirectWithBasepath) : redirectWithBasepath;
+                const redirectError = createRedirectErrorForAction(redirectHref, navigateType);
+                reject(redirectError);
+            }
+        } else {
+            // If there's no redirect, resolve the action with the result.
+            resolve(actionResult);
+        }
+        // Check if we can bail out without updating any state.
+        if (// Did the action trigger a redirect?
+        redirectLocation === undefined && // Did the action revalidate any data?
+        revalidationKind === _actionrevalidationkind.ActionDidNotRevalidate && // Did the server render new data?
+        flightData === undefined) {
+            // The action did not trigger any revalidations or redirects. No
+            // navigation is required.
+            return state;
+        }
+        if (flightData === undefined && redirectLocation !== undefined) {
+            // The server redirected, but did not send any Flight data. This implies
+            // an external redirect.
+            // TODO: We should refactor the action response type to be more explicit
+            // about the various response types.
+            return (0, _navigation.completeHardNavigation)(state, redirectLocation, navigateType);
+        }
+        if (typeof flightData === 'string') {
+            // If the flight data is just a string, something earlier in the
+            // response handling triggered an external redirect.
+            return (0, _navigation.completeHardNavigation)(state, new URL(flightData, location.origin), navigateType);
+        }
+        // The action triggered a navigation — either a redirect, a revalidation,
+        // or both.
+        // If there was no redirect, then the target URL is the same as the
+        // current URL.
+        const currentUrl = new URL(state.canonicalUrl, location.origin);
+        const currentRenderedSearch = state.renderedSearch;
+        const redirectUrl = redirectLocation !== undefined ? redirectLocation : currentUrl;
+        const currentFlightRouterState = state.tree;
+        const scrollBehavior = _routerreducertypes.ScrollBehavior.Default;
+        // If the action triggered a revalidation of the cache, we should also
+        // refresh all the dynamic data.
+        const freshnessPolicy = revalidationKind === _actionrevalidationkind.ActionDidNotRevalidate ? _pprnavigations.FreshnessPolicy.Default : _pprnavigations.FreshnessPolicy.RefreshAll;
+        // The server may have sent back new data. If so, we will perform a
+        // "seeded" navigation that uses the data from the response.
+        // TODO: Currently the server always renders from the root in
+        // response to a Server Action. In the case of a normal redirect
+        // with no revalidation, it should skip over the shared layouts.
+        if (flightData !== undefined && flightDataRenderedSearch !== undefined) {
+            // The server sent back new route data as part of the response. We
+            // will use this to render the new page. If this happens to be only a
+            // subset of the data needed to render the new page, we'll initiate a
+            // new fetch, like we would for a normal navigation.
+            const redirectCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(redirectUrl);
+            const now = Date.now();
+            // TODO: Store the dynamic stale time on the top-level state so it's
+            // known during restores and refreshes.
+            const redirectSeed = (0, _navigation.convertServerPatchToFullTree)(now, currentFlightRouterState, flightData, flightDataRenderedSearch, _bfcache.UnknownDynamicStaleTime);
+            // Learn the route pattern so we can predict it for future navigations.
+            const metadataVaryPath = redirectSeed.metadataVaryPath;
+            if (metadataVaryPath !== null) {
+                (0, _optimisticroutes.discoverKnownRoute)(now, redirectUrl.pathname, nextUrl, null, redirectSeed.routeTree, metadataVaryPath, couldBeIntercepted, redirectCanonicalUrl, isPrerender, false // hasDynamicRewrite
+                );
+            }
+            return (0, _navigation.navigateToKnownRoute)(now, state, redirectUrl, redirectCanonicalUrl, redirectSeed, currentUrl, currentRenderedSearch, state.cache, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, null, // Server action redirects don't use route prediction - we already
+            // have the route tree from the server response. If a mismatch occurs
+            // during dynamic data fetch, the retry handler will traverse the
+            // known route tree to mark the entry as having a dynamic rewrite.
+            null);
+        }
+        // The server did not send back new data. We'll perform a regular, non-
+        // seeded navigation — effectively the same as <Link> or router.push().
+        return (0, _navigation.navigate)(state, redirectUrl, currentUrl, currentRenderedSearch, state.cache, currentFlightRouterState, nextUrl, freshnessPolicy, scrollBehavior, navigateType);
+    }, (e)=>{
+        // When the server action is rejected we don't update the state and instead call the reject handler of the promise.
+        reject(e);
+        return state;
+    });
+}
+function createRedirectErrorForAction(redirectHref, resolvedRedirectType) {
+    const redirectError = (0, _redirect.getRedirectError)(redirectHref, resolvedRedirectType);
+    redirectError.handled = true;
+    return redirectError;
+}
+
+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=server-action-reducer.js.map

node_modules/next/dist/client/components/router-reducer/reducers/server-patch-reducer.d.ts

@@ -0,0 +1,2 @@
+import { type ServerPatchAction, type ReducerState, type ReadonlyReducerState } from '../router-reducer-types';
+export declare function serverPatchReducer(state: ReadonlyReducerState, action: ServerPatchAction): ReducerState;

node_modules/next/dist/client/components/router-reducer/reducers/server-patch-reducer.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serverPatchReducer", {
+    enumerable: true,
+    get: function() {
+        return serverPatchReducer;
+    }
+});
+const _createhreffromurl = require("../create-href-from-url");
+const _routerreducertypes = require("../router-reducer-types");
+const _navigation = require("../../segment-cache/navigation");
+const _refreshreducer = require("./refresh-reducer");
+const _pprnavigations = require("../ppr-navigations");
+function serverPatchReducer(state, action) {
+    // A "retry" is a navigation that happens due to a route mismatch. It's
+    // similar to a refresh, because we will omit any existing dynamic data on
+    // the page. But we seed the retry navigation with the exact tree that the
+    // server just responded with.
+    const retryMpa = action.mpa;
+    const retryUrl = new URL(action.url, location.origin);
+    const retrySeed = action.seed;
+    const navigateType = action.navigateType;
+    if (retryMpa || retrySeed === null) {
+        // If the server did not send back data during the mismatch, fall back to
+        // an MPA navigation.
+        return (0, _navigation.completeHardNavigation)(state, retryUrl, navigateType);
+    }
+    const currentUrl = new URL(state.canonicalUrl, location.origin);
+    const currentRenderedSearch = state.renderedSearch;
+    if (action.previousTree !== state.tree) {
+        // There was another, more recent navigation since the once that
+        // mismatched. We can abort the retry, but we still need to refresh the
+        // page to evict any stale dynamic data.
+        return (0, _refreshreducer.refreshReducer)(state, {
+            type: _routerreducertypes.ACTION_REFRESH
+        });
+    }
+    // There have been no new navigations since the mismatched one. Refresh,
+    // using the tree we just received from the server.
+    const retryCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(retryUrl);
+    const retryNextUrl = action.nextUrl;
+    const scrollBehavior = _routerreducertypes.ScrollBehavior.Default;
+    const now = Date.now();
+    return (0, _navigation.navigateToKnownRoute)(now, state, retryUrl, retryCanonicalUrl, retrySeed, currentUrl, currentRenderedSearch, state.cache, state.tree, _pprnavigations.FreshnessPolicy.RefreshAll, retryNextUrl, scrollBehavior, navigateType, null, // Server patch (retry) navigations don't use route prediction. This is
+    // typically a retry after a previous mismatch, so the route was already
+    // marked as having a dynamic rewrite when the mismatch was detected.
+    null);
+}
+
+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=server-patch-reducer.js.map

node_modules/next/dist/client/components/router-reducer/reducers/server-patch-reducer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/client/components/router-reducer/reducers/server-patch-reducer.ts"],"sourcesContent":["import { createHrefFromUrl } from '../create-href-from-url'\nimport {\n  ACTION_REFRESH,\n  type ServerPatchAction,\n  type ReducerState,\n  type ReadonlyReducerState,\n  ScrollBehavior,\n} from '../router-reducer-types'\nimport {\n  completeHardNavigation,\n  navigateToKnownRoute,\n} from '../../segment-cache/navigation'\nimport { refreshReducer } from './refresh-reducer'\nimport { FreshnessPolicy } from '../ppr-navigations'\n\nexport function serverPatchReducer(\n  state: ReadonlyReducerState,\n  action: ServerPatchAction\n): ReducerState {\n  // A \"retry\" is a navigation that happens due to a route mismatch. It's\n  // similar to a refresh, because we will omit any existing dynamic data on\n  // the page. But we seed the retry navigation with the exact tree that the\n  // server just responded with.\n  const retryMpa = action.mpa\n  const retryUrl = new URL(action.url, location.origin)\n  const retrySeed = action.seed\n  const navigateType = action.navigateType\n  if (retryMpa || retrySeed === null) {\n    // If the server did not send back data during the mismatch, fall back to\n    // an MPA navigation.\n    return completeHardNavigation(state, retryUrl, navigateType)\n  }\n  const currentUrl = new URL(state.canonicalUrl, location.origin)\n  const currentRenderedSearch = state.renderedSearch\n  if (action.previousTree !== state.tree) {\n    // There was another, more recent navigation since the once that\n    // mismatched. We can abort the retry, but we still need to refresh the\n    // page to evict any stale dynamic data.\n    return refreshReducer(state, { type: ACTION_REFRESH })\n  }\n  // There have been no new navigations since the mismatched one. Refresh,\n  // using the tree we just received from the server.\n  const retryCanonicalUrl = createHrefFromUrl(retryUrl)\n  const retryNextUrl = action.nextUrl\n  const scrollBehavior = ScrollBehavior.Default\n  const now = Date.now()\n  return navigateToKnownRoute(\n    now,\n    state,\n    retryUrl,\n    retryCanonicalUrl,\n    retrySeed,\n    currentUrl,\n    currentRenderedSearch,\n    state.cache,\n    state.tree,\n    FreshnessPolicy.RefreshAll,\n    retryNextUrl,\n    scrollBehavior,\n    navigateType,\n    null,\n    // Server patch (retry) navigations don't use route prediction. This is\n    // typically a retry after a previous mismatch, so the route was already\n    // marked as having a dynamic rewrite when the mismatch was detected.\n    null\n  )\n}\n"],"names":["serverPatchReducer","state","action","retryMpa","mpa","retryUrl","URL","url","location","origin","retrySeed","seed","navigateType","completeHardNavigation","currentUrl","canonicalUrl","currentRenderedSearch","renderedSearch","previousTree","tree","refreshReducer","type","ACTION_REFRESH","retryCanonicalUrl","createHrefFromUrl","retryNextUrl","nextUrl","scrollBehavior","ScrollBehavior","Default","now","Date","navigateToKnownRoute","cache","FreshnessPolicy","RefreshAll"],"mappings":";;;;+BAegBA;;;eAAAA;;;mCAfkB;oCAO3B;4BAIA;gCACwB;gCACC;AAEzB,SAASA,mBACdC,KAA2B,EAC3BC,MAAyB;IAEzB,uEAAuE;IACvE,0EAA0E;IAC1E,0EAA0E;IAC1E,8BAA8B;IAC9B,MAAMC,WAAWD,OAAOE,GAAG;IAC3B,MAAMC,WAAW,IAAIC,IAAIJ,OAAOK,GAAG,EAAEC,SAASC,MAAM;IACpD,MAAMC,YAAYR,OAAOS,IAAI;IAC7B,MAAMC,eAAeV,OAAOU,YAAY;IACxC,IAAIT,YAAYO,cAAc,MAAM;QAClC,yEAAyE;QACzE,qBAAqB;QACrB,OAAOG,IAAAA,kCAAsB,EAACZ,OAAOI,UAAUO;IACjD;IACA,MAAME,aAAa,IAAIR,IAAIL,MAAMc,YAAY,EAAEP,SAASC,MAAM;IAC9D,MAAMO,wBAAwBf,MAAMgB,cAAc;IAClD,IAAIf,OAAOgB,YAAY,KAAKjB,MAAMkB,IAAI,EAAE;QACtC,gEAAgE;QAChE,uEAAuE;QACvE,wCAAwC;QACxC,OAAOC,IAAAA,8BAAc,EAACnB,OAAO;YAAEoB,MAAMC,kCAAc;QAAC;IACtD;IACA,wEAAwE;IACxE,mDAAmD;IACnD,MAAMC,oBAAoBC,IAAAA,oCAAiB,EAACnB;IAC5C,MAAMoB,eAAevB,OAAOwB,OAAO;IACnC,MAAMC,iBAAiBC,kCAAc,CAACC,OAAO;IAC7C,MAAMC,MAAMC,KAAKD,GAAG;IACpB,OAAOE,IAAAA,gCAAoB,EACzBF,KACA7B,OACAI,UACAkB,mBACAb,WACAI,YACAE,uBACAf,MAAMgC,KAAK,EACXhC,MAAMkB,IAAI,EACVe,+BAAe,CAACC,UAAU,EAC1BV,cACAE,gBACAf,cACA,MACA,uEAAuE;IACvE,wEAAwE;IACxE,qEAAqE;IACrE;AAEJ","ignoreList":[0]}