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

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

@@ -36,11 +36,7 @@ function createPrefetchURL(href) {
     } catch (_) {
         // TODO: Does this need to throw or can we just console.error instead? Does
         // anyone rely on this throwing? (Seems unlikely.)
-        throw Object.defineProperty(new Error(`Cannot prefetch '${href}' because it cannot be converted to a URL.`), "__NEXT_ERROR_CODE", {
-            value: "E234",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Cannot prefetch '${href}' because it cannot be converted to a URL.`);
     }
     // Don't prefetch during development (improves compilation performance)
     if (process.env.NODE_ENV === 'development') {

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

@@ -13,20 +13,20 @@ const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildc
 const _jsxruntime = require("react/jsx-runtime");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _approutercontextsharedruntime = require("../../shared/lib/app-router-context.shared-runtime");
-const _routerreducertypes = require("./router-reducer/router-reducer-types");
 const _createhreffromurl = require("./router-reducer/create-href-from-url");
+const _createsegmentkey = require("./router-reducer/create-segment-key");
 const _hooksclientcontextsharedruntime = require("../../shared/lib/hooks-client-context.shared-runtime");
 const _useactionqueue = require("./use-action-queue");
 const _committedstate = require("./router-reducer/reducers/committed-state");
 const _approuterannouncer = require("./app-router-announcer");
 const _redirectboundary = require("./redirect-boundary");
-const _findheadincache = require("./router-reducer/reducers/find-head-in-cache");
 const _unresolvedthenable = require("./unresolved-thenable");
 const _removebasepath = require("../remove-base-path");
 const _hasbasepath = require("../has-base-path");
 const _computechangedpath = require("./router-reducer/compute-changed-path");
 const _navfailurehandler = require("./nav-failure-handler");
 const _approuterinstance = require("./app-router-instance");
+const _navigator = require("./navigator");
 const _redirect = require("./redirect");
 const _redirecterror = require("./redirect-error");
 const _links = require("./links");
@@ -35,6 +35,41 @@ const _globalerror = /*#__PURE__*/ _interop_require_default._(require("./builtin
 const _boundarycomponents = require("../../lib/framework/boundary-components");
 const _deploymentid = require("../../shared/lib/deployment-id");
 const globalMutable = {};
+// A Back/Forward press before the router's popstate listener exists moves the
+// browser to a different history entry than the one the document was activated
+// on, and the resulting popstate fires with nobody listening. The activation
+// entry is fixed for the document's lifetime and entry keys are stable across
+// replaceState, so until the listener is installed a key mismatch means a
+// traversal went unobserved.
+function hasMissedTraversal() {
+    if (typeof window.navigation === 'undefined') {
+        return false;
+    }
+    const activationEntry = window.navigation.activation?.entry;
+    const currentEntry = window.navigation.currentEntry;
+    return activationEntry != null && currentEntry != null && activationEntry.key !== currentEntry.key && // Only entries written by the app router can be restored; on any other
+    // entry the traversal is left unhandled, as before.
+    window.history.state?.__NA === true;
+}
+let checkedMissedTraversalBeforeHistoryWrite = false;
+let checkedMissedTraversalBeforeReplay = false;
+/**
+ * Handles a popstate event (or one that was missed before hydration).
+ * By default dispatches ACTION_RESTORE, however if the history entry was not
+ * pushed/replaced by app-router it will reload the page.
+ * That case can happen when the old router injected the history entry.
+ */ function handlePopState(state) {
+    if (!state) {
+        // TODO-APP: this case only happens when pushState/replaceState was called outside of Next.js. It should probably reload the page in this case.
+        return;
+    }
+    // This case happens when the history entry was pushed by the `pages` router.
+    if (!state.__NA) {
+        window.location.reload();
+        return;
+    }
+    (0, _navigator.traverse)(window.location.href, state.__PRIVATE_NEXTJS_INTERNALS_TREE);
+}
 function HistoryUpdater({ appRouterState }) {
     (0, _react.useInsertionEffect)(()=>{
         if (process.env.__NEXT_APP_NAV_FAIL_HANDLING) {
@@ -43,6 +78,15 @@ function HistoryUpdater({ appRouterState }) {
             window.next.__pendingUrl = undefined;
         }
         const { tree, pushRef, canonicalUrl, renderedSearch } = appRouterState;
+        if (!checkedMissedTraversalBeforeHistoryWrite) {
+            checkedMissedTraversalBeforeHistoryWrite = true;
+            if (hasMissedTraversal()) {
+                // Skip the write: it would overwrite the traversed-to entry's state.
+                // The tree was rendered even though the history write is skipped.
+                (0, _committedstate.setLastCommittedTree)(tree);
+                return;
+            }
+        }
         const appHistoryState = {
             tree,
             renderedSearch
@@ -74,10 +118,10 @@ function HistoryUpdater({ appRouterState }) {
         // task. Re-prefetch all visible links with the updated values. In most
         // cases, this will not result in any new network requests, only if
         // the prefetch result actually varies on one of these inputs.
-        (0, _links.pingVisibleLinks)(appRouterState.nextUrl, appRouterState.tree);
+        (0, _links.pingVisibleLinks)(appRouterState.nextUrl, appRouterState.root);
     }, [
         appRouterState.nextUrl,
-        appRouterState.tree
+        appRouterState.root
     ]);
     return null;
 }
@@ -94,12 +138,12 @@ function copyNextJsInternalHistoryState(data) {
     }
     return data;
 }
-function Head({ headCacheNode }) {
-    // If this segment has a `prefetchHead`, it's the statically prefetched data.
-    // We should use that on initial render instead of `head`. Then we'll switch
-    // to `head` when the dynamic response streams in.
-    const head = headCacheNode !== null ? headCacheNode.head : null;
-    const prefetchHead = headCacheNode !== null ? headCacheNode.prefetchHead : null;
+function Head({ headRenderTree }) {
+    // If the head has a `prefetchRsc`, it's the statically prefetched data. We
+    // should use that on initial render instead of `rsc`. Then we'll switch to
+    // `rsc` when the dynamic response streams in.
+    const head = headRenderTree.data.rsc;
+    const prefetchHead = headRenderTree.data.prefetchRsc;
     // If no prefetch data is available, then we go straight to rendering `head`.
     const resolvedPrefetchRsc = prefetchHead !== null ? prefetchHead : head;
     // We use `useDeferredValue` to handle switching between the prefetched and
@@ -124,7 +168,7 @@ function Head({ headCacheNode }) {
         canonicalUrl
     ]);
     if (process.env.NODE_ENV !== 'production') {
-        const { cache, tree } = state;
+        const { root, tree } = state;
         // This hook is in a conditional but that is ok because `process.env.NODE_ENV` never changes
         // eslint-disable-next-line react-hooks/rules-of-hooks
         (0, _react.useEffect)(()=>{
@@ -133,11 +177,11 @@ function Head({ headCacheNode }) {
             // @ts-ignore this is for debugging
             window.nd = {
                 router: _approuterinstance.publicAppRouterInstance,
-                cache,
+                root,
                 tree
             };
         }, [
-            cache,
+            root,
             tree
         ]);
     }
@@ -164,11 +208,7 @@ function Head({ headCacheNode }) {
             // This is necessary because if the browser restored from bfcache, the pendingMpaPath would still be set to the value
             // of the last MPA navigation.
             globalMutable.pendingMpaPath = undefined;
-            (0, _useactionqueue.dispatchAppRouterAction)({
-                type: _routerreducertypes.ACTION_RESTORE,
-                url: new URL(window.location.href),
-                historyState: window.history.state.__PRIVATE_NEXTJS_INTERNALS_TREE
-            });
+            (0, _navigator.restore)(new URL(window.location.href), window.history.state.__PRIVATE_NEXTJS_INTERNALS_TREE);
         }
         window.addEventListener('pageshow', handlePageShow);
         return ()=>{
@@ -237,13 +277,7 @@ function Head({ headCacheNode }) {
         const applyUrlFromHistoryPushReplace = (url)=>{
             const href = window.location.href;
             const appHistoryState = window.history.state?.__PRIVATE_NEXTJS_INTERNALS_TREE;
-            (0, _react.startTransition)(()=>{
-                (0, _useactionqueue.dispatchAppRouterAction)({
-                    type: _routerreducertypes.ACTION_RESTORE,
-                    url: new URL(url ?? href, href),
-                    historyState: appHistoryState
-                });
-            });
+            (0, _navigator.restore)(new URL(url ?? href, href), appHistoryState);
         };
         /**
      * Patch pushState to ensure external changes to the history are reflected in the Next.js Router.
@@ -277,41 +311,21 @@ function Head({ headCacheNode }) {
             }
             return originalReplaceState(data, _unused, url);
         };
-        /**
-     * Handle popstate event, this is used to handle back/forward in the browser.
-     * By default dispatches ACTION_RESTORE, however if the history entry was not pushed/replaced by app-router it will reload the page.
-     * That case can happen when the old router injected the history entry.
-     */ const onPopState = (event)=>{
-            if (!event.state) {
-                // TODO-APP: this case only happens when pushState/replaceState was called outside of Next.js. It should probably reload the page in this case.
-                return;
-            }
-            // This case happens when the history entry was pushed by the `pages` router.
-            if (!event.state.__NA) {
-                window.location.reload();
-                return;
-            }
-            // TODO-APP: Ideally the back button should not use startTransition as it should apply the updates synchronously
-            // Without startTransition works if the cache is there for this path
-            (0, _react.startTransition)(()=>{
-                (0, _approuterinstance.dispatchTraverseAction)(window.location.href, event.state.__PRIVATE_NEXTJS_INTERNALS_TREE);
-            });
-        };
-        // Register popstate event to call onPopstate.
+        const onPopState = (event)=>handlePopState(event.state);
         window.addEventListener('popstate', onPopState);
+        if (!checkedMissedTraversalBeforeReplay) {
+            checkedMissedTraversalBeforeReplay = true;
+            if (hasMissedTraversal()) {
+                handlePopState(window.history.state);
+            }
+        }
         return ()=>{
             window.history.pushState = originalPushState;
             window.history.replaceState = originalReplaceState;
             window.removeEventListener('popstate', onPopState);
         };
     }, []);
-    const { cache, tree, nextUrl, focusAndScrollRef, previousNextUrl } = state;
-    const matchingHead = (0, _react.useMemo)(()=>{
-        return (0, _findheadincache.findHeadInCache)(cache, tree[1]);
-    }, [
-        cache,
-        tree
-    ]);
+    const { root, tree, nextUrl, scrollRef, previousNextUrl } = state;
     // Add memoized pathParams for useParams.
     const pathParams = (0, _react.useMemo)(()=>{
         return (0, _computechangedpath.getSelectedParams)(tree);
@@ -329,7 +343,7 @@ function Head({ headCacheNode }) {
     const layoutRouterContext = (0, _react.useMemo)(()=>{
         return {
             parentTree: tree,
-            parentCacheNode: cache,
+            parentRenderTree: root.tree,
             parentSegmentPath: null,
             parentParams: {},
             parentLoadingData: null,
@@ -344,43 +358,38 @@ function Head({ headCacheNode }) {
         };
     }, [
         tree,
-        cache,
+        root,
         canonicalUrl
     ]);
     const globalLayoutRouterContext = (0, _react.useMemo)(()=>{
         return {
             tree,
-            focusAndScrollRef,
+            scrollRef,
             nextUrl,
             previousNextUrl
         };
     }, [
         tree,
-        focusAndScrollRef,
+        scrollRef,
         nextUrl,
         previousNextUrl
     ]);
-    let head;
-    if (matchingHead !== null) {
-        // The head is wrapped in an extra component so we can use
-        // `useDeferredValue` to swap between the prefetched and final versions of
-        // the head. (This is what LayoutRouter does for segment data, too.)
-        //
-        // The `key` is used to remount the component whenever the head moves to
-        // a different segment.
-        const [headCacheNode, headKey, headKeyWithoutSearchParams] = matchingHead;
-        head = /*#__PURE__*/ (0, _jsxruntime.jsx)(Head, {
-            headCacheNode: headCacheNode
-        }, // Necessary for PPR: omit search params from the key to match prerendered keys
-        typeof window === 'undefined' ? headKeyWithoutSearchParams : headKey);
-    } else {
-        head = null;
-    }
+    // The head is wrapped in an extra component so we can use
+    // `useDeferredValue` to swap between the prefetched and final versions of
+    // the head. (This is what LayoutRouter does for segment data, too.)
+    //
+    // The `key` is used to remount the component whenever the head moves to a
+    // different page, one of its path param values changes (the same inputs as
+    // LayoutRouter's keys), or its search params change. These are the entries
+    // of the head's vary path (see getHeadRequestKey).
+    const head = /*#__PURE__*/ (0, _jsxruntime.jsx)(Head, {
+        headRenderTree: root.head
+    }, (0, _createsegmentkey.createHeadKey)(root.head.varyPath));
     let content = /*#__PURE__*/ (0, _jsxruntime.jsxs)(_redirectboundary.RedirectBoundary, {
         children: [
             head,
             /*#__PURE__*/ (0, _jsxruntime.jsx)(_boundarycomponents.RootLayoutBoundary, {
-                children: cache.rsc
+                children: root.tree.data.rsc
             }),
             /*#__PURE__*/ (0, _jsxruntime.jsx)(_approuterannouncer.AppRouterAnnouncer, {
                 tree: tree

package/.next/standalone/node_modules/next/dist/client/components/dev-root-http-access-fallback-boundary.js

@@ -26,11 +26,7 @@ const _jsxruntime = require("react/jsx-runtime");
 const _react = /*#__PURE__*/ _interop_require_default._(require("react"));
 const _errorboundary = require("./http-access-fallback/error-boundary");
 function bailOnRootNotFound() {
-    throw Object.defineProperty(new Error('notFound() is not allowed to use in root layout'), "__NEXT_ERROR_CODE", {
-        value: "E192",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('notFound() is not allowed to use in root layout');
 }
 function NotAllowedRootHTTPFallbackError() {
     bailOnRootNotFound();

package/.next/standalone/node_modules/next/dist/client/components/forbidden.js

@@ -24,17 +24,9 @@ const _httpaccessfallback = require("./http-access-fallback/http-access-fallback
  */ const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};403`;
 function forbidden() {
     if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {
-        throw Object.defineProperty(new Error(`\`forbidden()\` is experimental and only allowed to be enabled when \`experimental.authInterrupts\` is enabled.`), "__NEXT_ERROR_CODE", {
-            value: "E488",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`\`forbidden()\` is experimental and only allowed to be enabled when \`experimental.authInterrupts\` is enabled.`);
     }
-    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E1019",
-        enumerable: false,
-        configurable: true
-    });
+    const error = new Error(DIGEST);
     error.digest = DIGEST;
     throw error;
 }

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

@@ -10,14 +10,29 @@ Object.defineProperty(exports, "handleISRError", {
 });
 const _serverasyncstorage = require("./server-async-storage");
 function handleISRError({ error }) {
-    if (_serverasyncstorage.workAsyncStorage) {
-        const store = _serverasyncstorage.workAsyncStorage.getStore();
-        if (store?.isStaticGeneration) {
+    if (!_serverasyncstorage.workUnitAsyncStorage) {
+        return;
+    }
+    const store = _serverasyncstorage.workUnitAsyncStorage.getStore();
+    switch(store?.type){
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-legacy':
             if (error) {
                 console.error(error);
             }
             throw error;
-        }
+        case 'request':
+        case 'prerender-runtime':
+        case 'validation-client':
+        case 'cache':
+        case 'private-cache':
+        case 'unstable-cache':
+        case 'build-time-generator':
+        case undefined:
+            return;
+        default:
+            store;
     }
 }
 

package/.next/standalone/node_modules/next/dist/client/components/instant-samples.js

@@ -44,13 +44,12 @@ function instrumentParamsForClientValidation(underlyingParams) {
             case 'prerender-runtime':
             case 'prerender-client':
             case 'prerender-legacy':
-            case 'prerender-ppr':
             case 'prerender':
             case 'cache':
             case 'request':
             case 'private-cache':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;
@@ -69,11 +68,7 @@ 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 \`unstable_samples\` of \`instant\`. ` + `${expression} requires all route params to be provided.`), "__NEXT_ERROR_CODE", {
-                                value: "E1191",
-                                enumerable: false,
-                                configurable: true
-                            }));
+                            (0, _instantsamples.trackMissingSampleErrorAndThrow)(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.`));
                         }
                     }
                     break;
@@ -81,13 +76,12 @@ function expectCompleteParamsInClientValidation(expression) {
             case 'prerender-runtime':
             case 'prerender-client':
             case 'prerender-legacy':
-            case 'prerender-ppr':
             case 'prerender':
             case 'cache':
             case 'request':
             case 'private-cache':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;
@@ -110,13 +104,12 @@ function instrumentSearchParamsForClientValidation(underlyingSearchParams) {
             case 'prerender-runtime':
             case 'prerender-client':
             case 'prerender-legacy':
-            case 'prerender-ppr':
             case 'prerender':
             case 'cache':
             case 'request':
             case 'private-cache':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;

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

@@ -268,32 +268,31 @@ function rescheduleLinkPrefetch(instance, priority) {
         require('./app-router-instance');
         const appRouterState = getCurrentAppRouterState();
         if (appRouterState !== null) {
-            const treeAtTimeOfPrefetch = appRouterState.tree;
             if (existingPrefetchTask === null) {
                 // 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, null // navigationLockPrefetch
+                instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, appRouterState.root, 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.
-                (0, _scheduler.reschedulePrefetchTask)(existingPrefetchTask, treeAtTimeOfPrefetch, instance.fetchStrategy, priority);
+                (0, _scheduler.reschedulePrefetchTask)(existingPrefetchTask, appRouterState.root, instance.fetchStrategy, priority);
             }
         }
     }
 }
-function pingVisibleLinks(nextUrl, tree) {
+function pingVisibleLinks(nextUrl, root) {
     // For each currently visible link, cancel the existing prefetch task (if it
     // exists) and schedule a new one. This is effectively the same as if all the
     // visible links left and then re-entered the viewport.
     //
-    // This is called when the Next-Url or the base tree changes, since those
+    // This is called when the Next-Url or the active cache tree changes, since those
     // may affect the result of a prefetch task. It's also called after a
     // cache invalidation.
     for (const instance of prefetchableAndVisible){
         const task = instance.prefetchTask;
-        if (task !== null && !(0, _scheduler.isPrefetchTaskDirty)(task, nextUrl, tree)) {
+        if (task !== null && !(0, _scheduler.isPrefetchTaskDirty)(task, nextUrl, root)) {
             continue;
         }
         // Something changed. Cancel the existing prefetch task and schedule a
@@ -302,7 +301,7 @@ 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, null // navigationLockPrefetch
+        instance.prefetchTask = (0, _scheduler.schedulePrefetchTask)(cacheKey, root, instance.fetchStrategy, _types.PrefetchPriority.Default, null, null // navigationLockPrefetch
         );
     }
 }

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

@@ -21,13 +21,13 @@ function _export(target, all) {
 }
 _export(exports, {
     useDynamicRouteParams: function() {
-        return _dynamicrendering.useDynamicRouteParams;
+        return _dynamicrenderingclient.useDynamicRouteParams;
     },
     useDynamicSearchParams: function() {
-        return _dynamicrendering.useDynamicSearchParams;
+        return _dynamicrenderingclient.useDynamicSearchParams;
     }
 });
-const _dynamicrendering = require("../../server/app-render/dynamic-rendering");
+const _dynamicrenderingclient = require("../../server/app-render/dynamic-rendering-client");
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });

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

@@ -27,7 +27,6 @@ const _serverasyncstorage = require("./server-async-storage");
         switch(workUnitStore.type){
             case 'prerender':
             case 'prerender-client':
-            case 'prerender-ppr':
             case 'validation-client':
                 const fallbackParams = workUnitStore.fallbackRouteParams;
                 return fallbackParams ? fallbackParams.size > 0 : false;
@@ -37,7 +36,7 @@ const _serverasyncstorage = require("./server-async-storage");
             case 'cache':
             case 'private-cache':
             case 'unstable-cache':
-            case 'generate-static-params':
+            case 'build-time-generator':
                 break;
             default:
                 workUnitStore;

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

@@ -145,11 +145,7 @@ function usePathname() {
 function useRouter() {
     const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
     if (router === null) {
-        throw Object.defineProperty(new Error('invariant expected app router to be mounted'), "__NEXT_ERROR_CODE", {
-            value: "E238",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('invariant expected app router to be mounted');
     }
     // Read the bfcacheId of the closest CacheNode and merge it into the
     // returned router instance. This is contextual: callers in a shared
@@ -159,7 +155,7 @@ function useRouter() {
     // 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;
+    const bfcacheIdNumber = layout?.parentRenderTree.data.bfcacheId ?? 0;
     return (0, _react.useMemo)(()=>({
             back: router.back,
             forward: router.forward,

package/.next/standalone/node_modules/next/dist/client/components/navigation.react-server.js

@@ -55,11 +55,7 @@ const _forbidden = require("./forbidden");
 const _unauthorized = require("./unauthorized");
 const _unstablerethrow = require("./unstable-rethrow");
 function unstable_isUnrecognizedActionError() {
-    throw Object.defineProperty(new Error('`unstable_isUnrecognizedActionError` can only be used on the client.'), "__NEXT_ERROR_CODE", {
-        value: "E776",
-        enumerable: false,
-        configurable: true
-    });
+    throw new Error('`unstable_isUnrecognizedActionError` can only be used on the client.');
 }
 const RedirectType = {
     push: 'push',

package/.next/standalone/node_modules/next/dist/client/components/navigator.js

@@ -0,0 +1,73 @@
+// This module is the router's operation interface: one function per
+// user-facing operation, called directly by the corresponding entry points
+// (Link, the public router methods, the history event handlers).
+//
+// The navigator owns the startTransition for its operations, along with the
+// centralized safety checks; callers must invoke these functions
+// synchronously within the originating event.
+//
+// Server Actions are not a navigator operation: the action queue is
+// semantically separate from the router state queue. Its entry point is
+// callServer (app-call-server.ts), which forks the same way.
+//
+// This is the seam where the experimental rewrite of the router state
+// machine forks from the existing implementation, so nothing above this
+// interface may depend on how the operations are processed. The fork happens
+// at the bundler level: by default this module re-exports the sequential
+// router queue, but when `experimental.concurrentRouterQueue` is enabled,
+// imports of this module resolve to './concurrent-router-queue' instead —
+// neither this module nor the sequential implementation is bundled at all.
+// The aliases live in create-compiler-aliases.ts (webpack/rspack) and
+// next_import_map.rs (Turbopack). The export list below is the interface;
+// both implementations expose exactly this surface.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    hmrRefresh: null,
+    navigate: null,
+    push: null,
+    refresh: null,
+    replace: null,
+    restore: null,
+    traverse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    hmrRefresh: function() {
+        return _sequentialrouterqueue.hmrRefresh;
+    },
+    navigate: function() {
+        return _sequentialrouterqueue.navigate;
+    },
+    push: function() {
+        return _sequentialrouterqueue.push;
+    },
+    refresh: function() {
+        return _sequentialrouterqueue.refresh;
+    },
+    replace: function() {
+        return _sequentialrouterqueue.replace;
+    },
+    restore: function() {
+        return _sequentialrouterqueue.restore;
+    },
+    traverse: function() {
+        return _sequentialrouterqueue.traverse;
+    }
+});
+const _sequentialrouterqueue = require("./sequential-router-queue");
+
+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=navigator.js.map

package/.next/standalone/node_modules/next/dist/client/components/not-found.js

@@ -24,11 +24,7 @@ const _httpaccessfallback = require("./http-access-fallback/http-access-fallback
  * Read more: [Next.js Docs: `notFound`](https://nextjs.org/docs/app/api-reference/functions/not-found)
  */ const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};404`;
 function notFound() {
-    const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
-        value: "E1041",
-        enumerable: false,
-        configurable: true
-    });
+    const error = new Error(DIGEST);
     error.digest = DIGEST;
     throw error;
 }