@evoscientist/webui 0.2.4 → 0.2.6

package/dist/node_modules/next/dist/client/components/app-router-instance.js

@@ -46,27 +46,31 @@ const _addbasepath = require("../add-base-path");
 const _approuterutils = require("./app-router-utils");
 const _links = require("./links");
 const _javascripturl = require("../lib/javascript-url");
-function runRemainingActions(actionQueue, setState) {
-    if (actionQueue.pending !== null) {
-        actionQueue.pending = actionQueue.pending.next;
+const _routertransition = require("./router-transition");
+function runRemainingActions(actionQueue, settledAction, setState) {
+    // Only advance the queue if the settled action is still at its head. If a
+    // navigation discarded this action, the navigation took its place and is
+    // still in flight — starting the next queued action now would run it
+    // against router state that doesn't include the navigation yet.
+    if (actionQueue.pending === settledAction) {
+        actionQueue.pending = settledAction.next;
         if (actionQueue.pending !== null) {
             runAction({
                 actionQueue,
                 action: actionQueue.pending,
                 setState
             });
-        }
-    } else {
-        // Check for refresh when pending is already null
-        // This handles the case where a discarded server action completes
-        // after the navigation has already finished and the queue is empty
-        if (actionQueue.needsRefresh) {
-            actionQueue.needsRefresh = false;
-            actionQueue.dispatch({
-                type: _routerreducertypes.ACTION_REFRESH
-            }, setState);
+            return;
         }
     }
+    if (actionQueue.pending === null && actionQueue.needsRefresh) {
+        // The queue is idle; flush the refresh requested by a discarded server
+        // action that revalidated data.
+        actionQueue.needsRefresh = false;
+        actionQueue.dispatch({
+            type: _routerreducertypes.ACTION_REFRESH
+        }, setState);
+    }
 }
 async function runAction({ actionQueue, action, setState }) {
     const prevState = actionQueue.state;
@@ -82,19 +86,19 @@ async function runAction({ actionQueue, action, setState }) {
                 // mark that we need to refresh after all actions complete
                 actionQueue.needsRefresh = true;
             }
-            // Still need to run remaining actions even for discarded actions
-            // to potentially trigger the refresh
-            runRemainingActions(actionQueue, setState);
+            // This can't advance the queue (this action is no longer its head), but
+            // if the queue has already drained, it flushes the refresh now.
+            runRemainingActions(actionQueue, action, setState);
             return;
         }
         actionQueue.state = nextState;
-        runRemainingActions(actionQueue, setState);
+        runRemainingActions(actionQueue, action, setState);
         action.resolve(nextState);
     }
     // if the action is a promise, set up a callback to resolve it
     if ((0, _isthenable.isThenable)(actionResult)) {
         actionResult.then(handleResult, (err)=>{
-            runRemainingActions(actionQueue, setState);
+            runRemainingActions(actionQueue, action, setState);
             action.reject(err);
         });
     } else {
@@ -147,6 +151,9 @@ function dispatchAction(actionQueue, payload, setState) {
         // The rest of the current queue should still execute after this navigation.
         // (Note that it can't contain any earlier navigations, because we always put those into `actionQueue.pending` by calling `runAction`)
         newAction.next = actionQueue.pending.next;
+        if (actionQueue.last === actionQueue.pending) {
+            actionQueue.last = newAction;
+        }
         runAction({
             actionQueue,
             action: newAction,
@@ -162,7 +169,7 @@ function dispatchAction(actionQueue, payload, setState) {
     }
 }
 let globalActionQueue = null;
-function createMutableActionQueue(initialState, instrumentationHooks) {
+function createMutableActionQueue(initialState) {
     const actionQueue = {
         state: initialState,
         dispatch: (payload, setState)=>dispatchAction(actionQueue, payload, setState),
@@ -171,8 +178,7 @@ function createMutableActionQueue(initialState, instrumentationHooks) {
             return result;
         },
         pending: null,
-        last: null,
-        onRouterTransitionStart: instrumentationHooks !== null && typeof instrumentationHooks.onRouterTransitionStart === 'function' ? instrumentationHooks.onRouterTransitionStart : null
+        last: null
     };
     if (typeof window !== 'undefined') {
         // The action queue is lazily created on hydration, but after that point
@@ -202,13 +208,7 @@ function getAppRouterActionQueue() {
     }
     return globalActionQueue;
 }
-function getProfilingHookForOnNavigationStart() {
-    if (globalActionQueue !== null) {
-        return globalActionQueue.onRouterTransitionStart;
-    }
-    return null;
-}
-function dispatchNavigateAction(href, navigateType, scrollBehavior, linkInstanceRef, transitionTypes) {
+function dispatchNavigateAction(href, navigateType, scrollBehavior, linkInstanceRef, transitionTypes, prefetchIntent) {
     // TODO: This stuff could just go into the reducer. Leaving as-is for now
     // since we're about to rewrite all the router reducer stuff anyway.
     if (transitionTypes) {
@@ -221,10 +221,7 @@ function dispatchNavigateAction(href, navigateType, scrollBehavior, linkInstance
         window.next.__pendingUrl = url;
     }
     (0, _links.setLinkForCurrentNavigation)(linkInstanceRef);
-    const onRouterTransitionStart = getProfilingHookForOnNavigationStart();
-    if (onRouterTransitionStart !== null) {
-        onRouterTransitionStart(href, navigateType);
-    }
+    (0, _routertransition.startRouterTransition)(href, navigateType, getAppRouterActionQueue().state.tree, prefetchIntent);
     (0, _useactionqueue.dispatchAppRouterAction)({
         type: _routerreducertypes.ACTION_NAVIGATE,
         url,
@@ -235,10 +232,7 @@ function dispatchNavigateAction(href, navigateType, scrollBehavior, linkInstance
     });
 }
 function dispatchTraverseAction(href, historyState) {
-    const onRouterTransitionStart = getProfilingHookForOnNavigationStart();
-    if (onRouterTransitionStart !== null) {
-        onRouterTransitionStart(href, 'traverse');
-    }
+    (0, _routertransition.startRouterTransition)(href, 'traverse', getAppRouterActionQueue().state.tree, null);
     (0, _useactionqueue.dispatchAppRouterAction)({
         type: _routerreducertypes.ACTION_RESTORE,
         url: new URL(href),
@@ -285,6 +279,9 @@ function dispatchTraverseAction(href, historyState) {
         (0, _useactionqueue.dispatchGestureState)(forkedGestureState);
     }
 }
+// Tracks the newest HMR refresh generation so that a newer refresh can abort
+// the request of the one it supersedes. Development only.
+let activeHmrRefreshController = null;
 const publicAppRouterInstance = {
     back: ()=>window.history.back(),
     forward: ()=>window.history.forward(),
@@ -337,7 +334,7 @@ const publicAppRouterInstance = {
             });
         }
         (0, _react.startTransition)(()=>{
-            dispatchNavigateAction(href, 'replace', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes);
+            dispatchNavigateAction(href, 'replace', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes, null);
         });
     },
     push: (href, options)=>{
@@ -349,7 +346,7 @@ const publicAppRouterInstance = {
             });
         }
         (0, _react.startTransition)(()=>{
-            dispatchNavigateAction(href, 'push', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes);
+            dispatchNavigateAction(href, 'push', options?.scroll === false ? _routerreducertypes.ScrollBehavior.NoScroll : _routerreducertypes.ScrollBehavior.Default, null, options?.transitionTypes, null);
         });
     },
     refresh: ()=>{
@@ -370,13 +367,26 @@ const publicAppRouterInstance = {
             // Reset the known routes table so that route predictions are cleared
             // when routes change during development.
             (0, _optimisticroutes.resetKnownRoutes)();
+            let signal;
+            if (process.env.__NEXT_SERVER_COMPONENTS_HMR_CANCELLATION) {
+                // Abort the superseded generation before scheduling the new one, so its
+                // request is torn down as early as possible. Halting (not rejecting)
+                // makes the abort safe regardless of order.
+                activeHmrRefreshController?.abort();
+                activeHmrRefreshController = new AbortController();
+                signal = activeHmrRefreshController.signal;
+            }
             (0, _react.startTransition)(()=>{
                 (0, _useactionqueue.dispatchAppRouterAction)({
-                    type: _routerreducertypes.ACTION_HMR_REFRESH
+                    type: _routerreducertypes.ACTION_HMR_REFRESH,
+                    signal
                 });
             });
         }
-    }
+    },
+    // Default value. Each route segment provides its own value at runtime. Refer
+    // to `useRouter()`.
+    bfcacheId: '0'
 };
 // Conditionally add experimental_gesturePush when gestureTransition is enabled
 if (process.env.__NEXT_GESTURE_TRANSITION) {

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

@@ -395,7 +395,9 @@ function Head({ headCacheNode }) {
         //  - render dev overlay
         //  - catch runtime errors and display global-error when necessary
         if (typeof window !== 'undefined') {
-            const { DevRootHTTPAccessFallbackBoundary } = require('./dev-root-http-access-fallback-boundary');
+            const { DevRootHTTPAccessFallbackBoundary } = // TODO(browser-variant): migrate to a .ts/.browser.ts split so the browser bundle drops the server branch; see scripts/generate-browser-variant-aliases.mjs
+            // ast-grep-ignore: no-typeof-window-require-tsx
+            require('./dev-root-http-access-fallback-boundary');
             content = /*#__PURE__*/ (0, _jsxruntime.jsx)(DevRootHTTPAccessFallbackBoundary, {
                 children: content
             });
@@ -414,6 +416,12 @@ function Head({ headCacheNode }) {
             children: content
         });
     }
+    if (process.env.__NEXT_USE_OFFLINE) {
+        const { OfflineProvider } = require('./use-offline');
+        content = /*#__PURE__*/ (0, _jsxruntime.jsx)(OfflineProvider, {
+            children: content
+        });
+    }
     return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
         children: [
             /*#__PURE__*/ (0, _jsxruntime.jsx)(HistoryUpdater, {

package/dist/node_modules/next/dist/client/components/error-boundary.js

@@ -40,7 +40,7 @@ class ErrorBoundaryHandler extends _react.default.Component {
             this.setState({
                 error: null
             });
-        }, this.unstable_retry = ()=>{
+        }, this.retry = ()=>{
             (0, _react.startTransition)(()=>{
                 this.context?.refresh();
                 this.reset();
@@ -51,14 +51,16 @@ class ErrorBoundaryHandler extends _react.default.Component {
             previousPathname: this.props.pathname
         };
     }
-    static getDerivedStateFromError(error) {
-        if ((0, _isnextroutererror.isNextRouterError)(error)) {
+    static getDerivedStateFromError(thrownValue) {
+        if ((0, _isnextroutererror.isNextRouterError)(thrownValue)) {
             // Re-throw if an expected internal Next.js router error occurs
             // this means it should be handled by a different boundary (such as a NotFound boundary in a parent segment)
-            throw error;
+            throw thrownValue;
         }
         return {
-            error
+            error: {
+                thrownValue
+            }
         };
     }
     static getDerivedStateFromProps(props, state) {
@@ -68,7 +70,7 @@ class ErrorBoundaryHandler extends _react.default.Component {
         // the error boundary and instead should fallback
         // to a hard navigation to attempt recovering
         if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
-            if (error && (0, _navfailurehandler.handleHardNavError)(error)) {
+            if (error && (0, _navfailurehandler.handleHardNavError)(error.thrownValue)) {
                 // clear error so we don't render anything
                 return {
                     error: null,
@@ -97,17 +99,19 @@ class ErrorBoundaryHandler extends _react.default.Component {
         //When it's bot request, segment level error boundary will keep rendering the children,
         // the final error will be caught by the root error boundary and determine wether need to apply graceful degrade.
         if (this.state.error && !isBotUserAgent) {
+            const thrownValue = this.state.error.thrownValue;
             (0, _handleisrerror.handleISRError)({
-                error: this.state.error
+                error: thrownValue
             });
             return /*#__PURE__*/ (0, _jsxruntime.jsxs)(_jsxruntime.Fragment, {
                 children: [
                     this.props.errorStyles,
                     this.props.errorScripts,
                     /*#__PURE__*/ (0, _jsxruntime.jsx)(this.props.errorComponent, {
-                        error: this.state.error,
+                        // TODO(NAR-804): Docs say this is an Error object, but we don't guarantee that
+                        error: thrownValue,
                         reset: this.reset,
-                        unstable_retry: this.unstable_retry
+                        retry: this.retry
                     })
                 ]
             });

package/dist/node_modules/next/dist/client/components/handle-isr-error.js

@@ -8,10 +8,10 @@ Object.defineProperty(exports, "handleISRError", {
         return handleISRError;
     }
 });
-const workAsyncStorage = typeof window === 'undefined' ? require('../../server/app-render/work-async-storage.external').workAsyncStorage : undefined;
+const _serverasyncstorage = require("./server-async-storage");
 function handleISRError({ error }) {
-    if (workAsyncStorage) {
-        const store = workAsyncStorage.getStore();
+    if (_serverasyncstorage.workAsyncStorage) {
+        const store = _serverasyncstorage.workAsyncStorage.getStore();
         if (store?.isStaticGeneration) {
             if (error) {
                 console.error(error);

package/dist/node_modules/next/dist/client/components/http-access-fallback/error-boundary.js

@@ -14,7 +14,6 @@ const _jsxruntime = require("react/jsx-runtime");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _navigationuntracked = require("../navigation-untracked");
 const _httpaccessfallback = require("./http-access-fallback");
-const _warnonce = require("../../../shared/lib/utils/warn-once");
 const _approutercontextsharedruntime = require("../../../shared/lib/app-router-context.shared-runtime");
 class HTTPAccessFallbackErrorBoundary extends _react.default.Component {
     constructor(props){
@@ -27,10 +26,11 @@ class HTTPAccessFallbackErrorBoundary extends _react.default.Component {
     componentDidCatch() {
         if (process.env.NODE_ENV === 'development' && this.props.missingSlots && this.props.missingSlots.size > 0 && // A missing children slot is the typical not-found case, so no need to warn
         !this.props.missingSlots.has('children')) {
+            const { warnOnce } = require('../../../shared/lib/utils/warn-once');
             let warningMessage = 'No default component was found for a parallel route rendered on this page. Falling back to nearest NotFound boundary.\n' + 'Learn more: https://nextjs.org/docs/app/building-your-application/routing/parallel-routes#defaultjs\n\n';
             const formattedSlots = Array.from(this.props.missingSlots).sort((a, b)=>a.localeCompare(b)).map((slot)=>`@${slot}`).join(', ');
             warningMessage += 'Missing slots: ' + formattedSlots;
-            (0, _warnonce.warnOnce)(warningMessage);
+            warnOnce(warningMessage);
         }
     }
     static getDerivedStateFromError(error) {

package/dist/node_modules/next/dist/{server/app-render/instant-validation/instant-samples-client.js → client/components/instant-samples.js}

@@ -24,10 +24,10 @@ _export(exports, {
         return instrumentSearchParamsForClientValidation;
     }
 });
-const _workunitasyncstorageexternal = require("../work-unit-async-storage.external");
-const _workasyncstorageexternal = require("../work-async-storage.external");
-const _instantsamples = require("./instant-samples");
-const _instantvalidationerror = require("./instant-validation-error");
+const _workunitasyncstorageexternal = require("../../server/app-render/work-unit-async-storage.external");
+const _workasyncstorageexternal = require("../../server/app-render/work-async-storage.external");
+const _instantsamples = require("../../server/app-render/instant-validation/instant-samples");
+const _instantvalidationerror = require("../../server/app-render/instant-validation/instant-validation-error");
 function instrumentParamsForClientValidation(underlyingParams) {
     const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
@@ -69,8 +69,8 @@ function expectCompleteParamsInClientValidation(expression) {
                         const fallbackParams = workUnitStore.fallbackRouteParams;
                         if (fallbackParams && fallbackParams.size > 0) {
                             const missingParams = Array.from(fallbackParams.keys());
-                            (0, _instantsamples.trackMissingSampleErrorAndThrow)(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${workStore.route}" called ${expression} but param${missingParams.length > 1 ? 's' : ''} ${missingParams.map((p)=>`"${p}"`).join(', ')} ${missingParams.length > 1 ? 'are' : 'is'} not defined in the \`samples\` of \`unstable_instant\`. ` + `${expression} requires all route params to be provided.`), "__NEXT_ERROR_CODE", {
-                                value: "E1109",
+                            (0, _instantsamples.trackMissingSampleErrorAndThrow)(Object.defineProperty(new _instantvalidationerror.InstantValidationError(`Route "${workStore.route}" called ${expression} but param${missingParams.length > 1 ? 's' : ''} ${missingParams.map((p)=>`"${p}"`).join(', ')} ${missingParams.length > 1 ? 'are' : 'is'} not defined in the \`unstable_samples\` of \`instant\`. ` + `${expression} requires all route params to be provided.`), "__NEXT_ERROR_CODE", {
+                                value: "E1191",
                                 enumerable: false,
                                 configurable: true
                             }));
@@ -125,4 +125,10 @@ function instrumentSearchParamsForClientValidation(underlyingSearchParams) {
     return underlyingSearchParams;
 }
 
-//# sourceMappingURL=instant-samples-client.js.map
+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=instant-samples.js.map

package/dist/node_modules/next/dist/client/components/links.js

@@ -112,7 +112,9 @@ function observeVisibility(element, instance) {
 }
 function coercePrefetchableUrl(href) {
     if (typeof window !== 'undefined') {
-        const { createPrefetchURL } = require('./app-router-utils');
+        const { createPrefetchURL } = // TODO(browser-variant): migrate to a .ts/.browser.ts split so the browser bundle drops the server branch; see scripts/generate-browser-variant-aliases.mjs
+        // ast-grep-ignore: no-typeof-window-require
+        require('./app-router-utils');
         try {
             return createPrefetchURL(href);
         } catch  {
@@ -129,7 +131,7 @@ function coercePrefetchableUrl(href) {
         return null;
     }
 }
-function mountLinkInstance(element, href, router, fetchStrategy, prefetchEnabled, setOptimisticLinkStatus) {
+function mountLinkInstance(element, href, router, fetchStrategy, prefetchEnabled, setOptimisticLinkStatus, ownerStack) {
     if (prefetchEnabled) {
         const prefetchURL = coercePrefetchableUrl(href);
         if (prefetchURL !== null) {
@@ -139,7 +141,8 @@ function mountLinkInstance(element, href, router, fetchStrategy, prefetchEnabled
                 isVisible: false,
                 prefetchTask: null,
                 prefetchHref: prefetchURL.href,
-                setOptimisticLinkStatus
+                setOptimisticLinkStatus,
+                ownerStack
             };
             // We only observe the link's visibility if it's prefetchable. For
             // example, this excludes links to external URLs.
@@ -155,7 +158,8 @@ function mountLinkInstance(element, href, router, fetchStrategy, prefetchEnabled
         isVisible: false,
         prefetchTask: null,
         prefetchHref: null,
-        setOptimisticLinkStatus
+        setOptimisticLinkStatus,
+        ownerStack
     };
     return instance;
 }
@@ -193,7 +197,16 @@ function unmountPrefetchableInstance(element) {
     }
 }
 function handleIntersect(entries) {
-    for (const entry of entries){
+    // Process the entries in reverse order. The prefetch scheduler assigns the
+    // highest priority to the most recently scheduled task, so whichever link we
+    // schedule *last* wins. When multiple links enter the viewport at once (e.g.
+    // on initial load), the observer reports them in document order, so iterating
+    // in reverse means the link nearest the top of the document is scheduled last
+    // and therefore prioritized. The topmost link isn't guaranteed to be the most
+    // important, but as a default heuristic it's more reasonable than prioritizing
+    // whichever link happens to be lowest in the document.
+    for(let i = entries.length - 1; i >= 0; i--){
+        const entry = entries[i];
         // Some extremely old browsers or polyfills don't reliably support
         // isIntersecting so we check intersectionRatio instead. (Do we care? Not
         // really. But whatever this is fine.)
@@ -250,7 +263,9 @@ function rescheduleLinkPrefetch(instance, priority) {
             // worry about whether an old task object is stale).
             return;
         }
-        const { getCurrentAppRouterState } = require('./app-router-instance');
+        const { getCurrentAppRouterState } = // TODO(browser-variant): migrate to a .ts/.browser.ts split so the browser bundle drops the server branch; see scripts/generate-browser-variant-aliases.mjs
+        // ast-grep-ignore: no-typeof-window-require
+        require('./app-router-instance');
         const appRouterState = getCurrentAppRouterState();
         if (appRouterState !== null) {
             const treeAtTimeOfPrefetch = appRouterState.tree;
@@ -258,7 +273,8 @@ function rescheduleLinkPrefetch(instance, priority) {
                 // Initiate a prefetch task.
                 const nextUrl = appRouterState.nextUrl;
                 const cacheKey = (0, _cachekey.createCacheKey)(instance.prefetchHref, nextUrl);
-                instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, treeAtTimeOfPrefetch, instance.fetchStrategy, priority, null);
+                instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, treeAtTimeOfPrefetch, instance.fetchStrategy, priority, null, null // navigationLockPrefetch
+                );
             } else {
                 // We already have an old task object that we can reschedule. This is
                 // effectively the same as canceling the old task and creating a new one.
@@ -286,7 +302,8 @@ function pingVisibleLinks(nextUrl, tree) {
             (0, _scheduler.cancelPrefetchTask)(task);
         }
         const cacheKey = (0, _cachekey.createCacheKey)(instance.prefetchHref, nextUrl);
-        instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, tree, instance.fetchStrategy, _types.PrefetchPriority.Default, null);
+        instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, tree, instance.fetchStrategy, _types.PrefetchPriority.Default, null, null // navigationLockPrefetch
+        );
     }
 }
 

package/dist/node_modules/next/dist/client/components/nav-failure-handler.js

@@ -23,7 +23,7 @@ _export(exports, {
 const _react = require("react");
 const _createhreffromurl = require("./router-reducer/create-href-from-url");
 function handleHardNavError(error) {
-    if (error && typeof window !== 'undefined' && window.next.__pendingUrl && (0, _createhreffromurl.createHrefFromUrl)(new URL(window.location.href)) !== (0, _createhreffromurl.createHrefFromUrl)(window.next.__pendingUrl)) {
+    if (typeof window !== 'undefined' && window.next.__pendingUrl && (0, _createhreffromurl.createHrefFromUrl)(new URL(window.location.href)) !== (0, _createhreffromurl.createHrefFromUrl)(window.next.__pendingUrl)) {
         console.error(`Error occurred during navigation, falling back to hard navigation`, error);
         window.location.href = window.next.__pendingUrl.toString();
         return true;

package/dist/node_modules/next/dist/client/components/navigation-dynamic-rendering.js

@@ -0,0 +1,38 @@
+// Client-safe access to the server-only dynamic-rendering hooks used by the
+// navigation hooks. On the server these re-export the real implementations; in
+// the browser bundle this module is aliased to
+// `./navigation-dynamic-rendering.browser` (see
+// scripts/generate-browser-variant-aliases.mjs), which exports `undefined` so
+// the server module is not bundled into the client. Callers use optional calls
+// (`useDynamicRouteParams?.(...)`), so the browser stub is a no-op.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    useDynamicRouteParams: null,
+    useDynamicSearchParams: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useDynamicRouteParams: function() {
+        return _dynamicrendering.useDynamicRouteParams;
+    },
+    useDynamicSearchParams: function() {
+        return _dynamicrendering.useDynamicSearchParams;
+    }
+});
+const _dynamicrendering = require("../../server/app-render/dynamic-rendering");
+
+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=navigation-dynamic-rendering.js.map

package/dist/node_modules/next/dist/client/components/navigation-untracked.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "useUntrackedPathname", {
 });
 const _react = require("react");
 const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-context.shared-runtime");
+const _serverasyncstorage = require("./server-async-storage");
 /**
  * This checks to see if the current render has any unknown route parameters that
  * would cause the pathname to be dynamic. It's used to trigger a different
@@ -17,10 +18,11 @@ const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-
  *
  * @returns true if there are any unknown route parameters, false otherwise
  */ function hasFallbackRouteParams() {
+    // The AsyncLocalStorage module is kept out of the client bundle via the
+    // `./server-async-storage` browser alias; the guard ensures the stub is never
+    // dereferenced in the browser.
     if (typeof window === 'undefined') {
-        // AsyncLocalStorage should not be included in the client bundle.
-        const { workUnitAsyncStorage } = require('../../server/app-render/work-unit-async-storage.external');
-        const workUnitStore = workUnitAsyncStorage.getStore();
+        const workUnitStore = _serverasyncstorage.workUnitAsyncStorage.getStore();
         if (!workUnitStore) return false;
         switch(workUnitStore.type){
             case 'prerender':

package/dist/node_modules/next/dist/client/components/navigation.js

@@ -87,14 +87,13 @@ const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _approutercontextsharedruntime = require("../../shared/lib/app-router-context.shared-runtime");
 const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-context.shared-runtime");
 const _segment = require("../../shared/lib/segment");
+const _navigationdynamicrendering = require("./navigation-dynamic-rendering");
 const _serverinsertedhtmlsharedruntime = require("../../shared/lib/server-inserted-html.shared-runtime");
 const _unrecognizedactionerror = require("./unrecognized-action-error");
 const _navigationreactserver = require("./navigation.react-server");
-const useDynamicRouteParams = typeof window === 'undefined' ? require('../../server/app-render/dynamic-rendering').useDynamicRouteParams : undefined;
-const useDynamicSearchParams = typeof window === 'undefined' ? require('../../server/app-render/dynamic-rendering').useDynamicSearchParams : undefined;
-const { instrumentParamsForClientValidation, instrumentSearchParamsForClientValidation, expectCompleteParamsInClientValidation } = typeof window === 'undefined' && process.env.__NEXT_CACHE_COMPONENTS ? require('../../server/app-render/instant-validation/instant-samples-client') : {};
+const { instrumentParamsForClientValidation, instrumentSearchParamsForClientValidation, expectCompleteParamsInClientValidation } = process.env.__NEXT_CACHE_COMPONENTS ? require('./instant-samples') : {};
 function useSearchParams() {
-    useDynamicSearchParams?.('useSearchParams()');
+    _navigationdynamicrendering.useDynamicSearchParams?.('useSearchParams()');
     const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
     // In the case where this is `null`, the compat types added in
     // `next-env.d.ts` will add a new overload that changes the return type to
@@ -124,7 +123,7 @@ function useSearchParams() {
     return readonlySearchParams;
 }
 function usePathname() {
-    useDynamicRouteParams?.('usePathname()');
+    _navigationdynamicrendering.useDynamicRouteParams?.('usePathname()');
     // In the case where this is `null`, the compat types added in `next-env.d.ts`
     // will add a new overload that changes the return type to include `null`.
     const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
@@ -152,10 +151,32 @@ function useRouter() {
             configurable: true
         });
     }
-    return router;
+    // Read the bfcacheId of the closest CacheNode and merge it into the
+    // returned router instance. This is contextual: callers in a shared
+    // layout get the layout's id; callers in a leaf segment get the leaf's.
+    // The id is stored on the CacheNode as a number and materialized as a
+    // string here. The format mirrors React's `useId()` (e.g. `_r_0_`) with
+    // a `b` prefix, so the id can be safely concatenated with other keys
+    // without collision.
+    const layout = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
+    const bfcacheIdNumber = layout?.parentCacheNode.bfcacheId ?? 0;
+    return (0, _react.useMemo)(()=>({
+            back: router.back,
+            forward: router.forward,
+            refresh: router.refresh,
+            hmrRefresh: router.hmrRefresh,
+            push: router.push,
+            replace: router.replace,
+            prefetch: router.prefetch,
+            experimental_gesturePush: router.experimental_gesturePush,
+            bfcacheId: '_b_' + bfcacheIdNumber + '_'
+        }), [
+        router,
+        bfcacheIdNumber
+    ]);
 }
 function useParams() {
-    useDynamicRouteParams?.('useParams()');
+    _navigationdynamicrendering.useDynamicRouteParams?.('useParams()');
     const params = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
     // During build-time instant validation, wrap with a proxy
     // so that accessing undeclared params throws an error.
@@ -172,7 +193,7 @@ function useParams() {
     return params;
 }
 function useSelectedLayoutSegments(parallelRouteKey = 'children') {
-    useDynamicRouteParams?.('useSelectedLayoutSegments()');
+    _navigationdynamicrendering.useDynamicRouteParams?.('useSelectedLayoutSegments()');
     const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
     // @ts-expect-error This only happens in `pages`. Type is overwritten in navigation.d.ts
     if (!context) return null;
@@ -196,7 +217,7 @@ function useSelectedLayoutSegments(parallelRouteKey = 'children') {
     return (0, _segment.getSelectedLayoutSegmentPath)(context.parentTree, parallelRouteKey);
 }
 function useSelectedLayoutSegment(parallelRouteKey = 'children') {
-    useDynamicRouteParams?.('useSelectedLayoutSegment()');
+    _navigationdynamicrendering.useDynamicRouteParams?.('useSelectedLayoutSegment()');
     const navigationPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
     const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
     // During build-time instant validation, error if fallback params exist