@semiont/frontend 0.3.2 → 0.3.4

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

@@ -13,34 +13,36 @@ 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 _navigatereducer = require("./navigate-reducer");
 const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
 const _flightdatahelpers = require("../../../flight-data-helpers");
 const _redirect = require("../../redirect");
-const _redirecterror = require("../../redirect-error");
 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.NODE_ENV !== 'production' && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
+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);
-    // TODO: Currently, we're only omitting unused args for the experimental "use
-    // cache" functions. Once the server reference info byte feature is stable, we
-    // should apply this to server actions as well.
-    const usedArgs = info.type === 'use-cache' ? (0, _serverreferenceinfo.omitUnusedArgs)(actionArgs, info) : actionArgs;
+    const usedArgs = (0, _serverreferenceinfo.omitUnusedArgs)(actionArgs, info);
     const body = await (0, _client.encodeReply)(usedArgs, {
         temporaryReferences
     });
@@ -56,7 +58,7 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
     if (nextUrl) {
         headers[_approuterheaders.NEXT_URL] = nextUrl;
     }
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.__NEXT_DEV_SERVER) {
         if (self.__next_r) {
             headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] = self.__next_r;
         }
@@ -84,10 +86,10 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
     let redirectType;
     switch(_redirectType){
         case 'push':
-            redirectType = _redirecterror.RedirectType.push;
+            redirectType = 'push';
             break;
         case 'replace':
-            redirectType = _redirecterror.RedirectType.replace;
+            redirectType = 'replace';
             break;
         default:
             redirectType = undefined;
@@ -122,9 +124,13 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
     let actionResult;
     let actionFlightData;
     let actionFlightDataRenderedSearch;
-    let actionFlightDataCouldBeIntercepted;
+    let couldBeIntercepted = false;
     if (isRscResponse) {
-        const response = await createFromFetch(Promise.resolve(res), {
+        // 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,
@@ -132,34 +138,46 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
         });
         // An internal redirect can send an RSC response, but does not have a useful `actionResult`.
         actionResult = redirectLocation ? undefined : response.a;
-        const maybeFlightData = (0, _flightdatahelpers.normalizeFlightData)(response.f);
-        if (maybeFlightData !== '') {
-            actionFlightData = maybeFlightData;
-            actionFlightDataRenderedSearch = response.q;
-            actionFlightDataCouldBeIntercepted = response.i;
+        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;
-        actionFlightDataCouldBeIntercepted = undefined;
     }
     return {
         actionResult,
         actionFlightData,
         actionFlightDataRenderedSearch,
-        actionFlightDataCouldBeIntercepted,
         redirectLocation,
         redirectType,
         revalidationKind,
-        isPrerender
+        isPrerender,
+        couldBeIntercepted
     };
 }
 function serverActionReducer(state, action) {
     const { resolve, reject } = action;
-    const mutable = {};
-    mutable.preserveCustomHistoryState = false;
     // 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
@@ -170,22 +188,30 @@ function serverActionReducer(state, action) {
     // 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, actionFlightDataCouldBeIntercepted: flightDataCouldBeIntercepted, redirectLocation, redirectType })=>{
+    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 entire prefetch cache.
+            // 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.revalidateEntireCache)(nextUrl, state.tree);
+                (0, _cache.invalidateEntirePrefetchCache)(nextUrl, state.tree);
             }
+            // Start a cooldown before re-prefetching to allow CDN cache
+            // propagation.
+            (0, _scheduler.startRevalidationCooldown)();
         }
-        const pendingPush = redirectType !== _redirecterror.RedirectType.replace;
-        state.pushRef.pendingPush = pendingPush;
-        mutable.pendingPush = pendingPush;
+        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
@@ -193,18 +219,17 @@ function serverActionReducer(state, action) {
             // 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.
-            const resolvedRedirectType = redirectType || _redirecterror.RedirectType.push;
             if ((0, _approuterutils.isExternalURL)(redirectLocation)) {
                 // External redirect. Triggers an MPA navigation.
                 const redirectHref = redirectLocation.href;
-                const redirectError = createRedirectErrorForAction(redirectHref, resolvedRedirectType);
+                const redirectError = createRedirectErrorForAction(redirectHref, navigateType);
                 reject(redirectError);
-                return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectHref, pendingPush);
+                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, resolvedRedirectType);
+                const redirectError = createRedirectErrorForAction(redirectHref, navigateType);
                 reject(redirectError);
             }
         } else {
@@ -225,52 +250,55 @@ function serverActionReducer(state, action) {
             // an external redirect.
             // TODO: We should refactor the action response type to be more explicit
             // about the various response types.
-            return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectLocation.href, pendingPush);
+            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, _navigatereducer.handleExternalUrl)(state, mutable, flightData, pendingPush);
+            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 shouldScroll = true;
+        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.
-        if (flightData !== undefined) {
-            const normalizedFlightData = flightData[0];
-            if (normalizedFlightData !== undefined && // 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.
-            normalizedFlightData.isRootRender && flightDataRenderedSearch !== undefined && flightDataCouldBeIntercepted !== 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 navigationSeed = {
-                    tree: normalizedFlightData.tree,
-                    renderedSearch: flightDataRenderedSearch,
-                    data: normalizedFlightData.seedData,
-                    head: normalizedFlightData.head
-                };
-                const now = Date.now();
-                const result = (0, _navigation.navigateToSeededRoute)(now, redirectUrl, redirectCanonicalUrl, navigationSeed, currentUrl, state.cache, currentFlightRouterState, freshnessPolicy, nextUrl, shouldScroll);
-                return (0, _navigatereducer.handleNavigationResult)(redirectUrl, state, mutable, pendingPush, result);
+        // 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().
-        const result = (0, _navigation.navigate)(redirectUrl, currentUrl, state.cache, currentFlightRouterState, nextUrl, freshnessPolicy, shouldScroll, mutable);
-        return (0, _navigatereducer.handleNavigationResult)(redirectUrl, state, mutable, pendingPush, result);
+        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);

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

@@ -9,13 +9,11 @@ Object.defineProperty(exports, "serverPatchReducer", {
     }
 });
 const _createhreffromurl = require("../create-href-from-url");
-const _navigatereducer = require("./navigate-reducer");
+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) {
-    const mutable = {};
-    mutable.preserveCustomHistoryState = false;
     // 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
@@ -23,28 +21,32 @@ function serverPatchReducer(state, action) {
     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, _navigatereducer.handleExternalUrl)(state, mutable, retryUrl.href, false);
+        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);
+        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;
-    // A retry should not create a new history entry.
-    const pendingPush = false;
-    const shouldScroll = true;
+    const scrollBehavior = _routerreducertypes.ScrollBehavior.Default;
     const now = Date.now();
-    const result = (0, _navigation.navigateToSeededRoute)(now, retryUrl, retryCanonicalUrl, retrySeed, currentUrl, state.cache, state.tree, _pprnavigations.FreshnessPolicy.RefreshAll, retryNextUrl, shouldScroll);
-    return (0, _navigatereducer.handleNavigationResult)(retryUrl, state, mutable, pendingPush, result);
+    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') {

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

@@ -9,7 +9,8 @@ Object.defineProperty(exports, "__esModule", {
     ACTION_RESTORE: null,
     ACTION_SERVER_ACTION: null,
     ACTION_SERVER_PATCH: null,
-    PrefetchKind: null
+    PrefetchKind: null,
+    ScrollBehavior: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -38,6 +39,9 @@ _export(exports, {
     },
     PrefetchKind: function() {
         return PrefetchKind;
+    },
+    ScrollBehavior: function() {
+        return ScrollBehavior;
     }
 });
 const ACTION_REFRESH = 'refresh';
@@ -51,6 +55,11 @@ var PrefetchKind = /*#__PURE__*/ function(PrefetchKind) {
     PrefetchKind["FULL"] = "full";
     return PrefetchKind;
 }({});
+var ScrollBehavior = /*#__PURE__*/ function(ScrollBehavior) {
+    /** Use per-node ScrollRef to decide whether to scroll. */ ScrollBehavior[ScrollBehavior["Default"] = 0] = "Default";
+    /** Suppress scroll entirely (e.g. scroll={false} on Link or router.push). */ ScrollBehavior[ScrollBehavior["NoScroll"] = 1] = "NoScroll";
+    return ScrollBehavior;
+}({});
 
 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/standalone/node_modules/next/dist/client/components/router-reducer/router-reducer.js

@@ -33,7 +33,7 @@ const _serveractionreducer = require("./reducers/server-action-reducer");
             }
         case _routerreducertypes.ACTION_REFRESH:
             {
-                return (0, _refreshreducer.refreshReducer)(state);
+                return (0, _refreshreducer.refreshReducer)(state, action);
             }
         case _routerreducertypes.ACTION_HMR_REFRESH:
             {

package/standalone/node_modules/next/dist/client/components/segment-cache/bfcache.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    UnknownDynamicStaleTime: null,
+    computeDynamicStaleAt: null,
+    invalidateBfCache: null,
+    readFromBFCache: null,
+    readFromBFCacheDuringRegularNavigation: null,
+    updateBFCacheEntryStaleAt: null,
+    writeHeadToBFCache: null,
+    writeToBFCache: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    UnknownDynamicStaleTime: function() {
+        return UnknownDynamicStaleTime;
+    },
+    computeDynamicStaleAt: function() {
+        return computeDynamicStaleAt;
+    },
+    invalidateBfCache: function() {
+        return invalidateBfCache;
+    },
+    readFromBFCache: function() {
+        return readFromBFCache;
+    },
+    readFromBFCacheDuringRegularNavigation: function() {
+        return readFromBFCacheDuringRegularNavigation;
+    },
+    updateBFCacheEntryStaleAt: function() {
+        return updateBFCacheEntryStaleAt;
+    },
+    writeHeadToBFCache: function() {
+        return writeHeadToBFCache;
+    },
+    writeToBFCache: function() {
+        return writeToBFCache;
+    }
+});
+const _navigatereducer = require("../router-reducer/reducers/navigate-reducer");
+const _cachemap = require("./cache-map");
+const UnknownDynamicStaleTime = -1;
+function computeDynamicStaleAt(now, dynamicStaleTimeSeconds) {
+    return dynamicStaleTimeSeconds !== UnknownDynamicStaleTime ? now + dynamicStaleTimeSeconds * 1000 : now + _navigatereducer.DYNAMIC_STALETIME_MS;
+}
+const bfcacheMap = (0, _cachemap.createCacheMap)();
+let currentBfCacheVersion = 0;
+function invalidateBfCache() {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    currentBfCacheVersion++;
+}
+function writeToBFCache(now, varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt) {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    const entry = {
+        rsc,
+        prefetchRsc,
+        // TODO: These fields will be removed from both BFCacheEntry and
+        // SegmentCacheEntry. The head has its own separate cache entry.
+        head,
+        prefetchHead,
+        ref: null,
+        // TODO: This is just a heuristic. Getting the actual size of the segment
+        // isn't feasible because it's part of a larger streaming response. The
+        // LRU will still evict it, we just won't have a fully accurate total
+        // LRU size. However, we'll probably remove the size tracking from the LRU
+        // entirely and use memory pressure events instead.
+        size: 100,
+        navigatedAt: now,
+        // A back/forward navigation will disregard the stale time. This field is
+        // only relevant when staleTimes.dynamic is enabled or unstable_dynamicStaleTime
+        // is exported by a page.
+        staleAt: dynamicStaleAt,
+        version: currentBfCacheVersion
+    };
+    const isRevalidation = false;
+    (0, _cachemap.setInCacheMap)(bfcacheMap, varyPath, entry, isRevalidation);
+}
+function writeHeadToBFCache(now, varyPath, head, prefetchHead, dynamicStaleAt) {
+    // Read the special "segment" that represents the head data.
+    writeToBFCache(now, varyPath, head, prefetchHead, null, null, dynamicStaleAt);
+}
+function updateBFCacheEntryStaleAt(varyPath, newStaleAt) {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    const isRevalidation = false;
+    // Read with staleness bypass (-1) so we can update even stale entries
+    const entry = (0, _cachemap.getFromCacheMap)(-1, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation);
+    if (entry !== null) {
+        entry.staleAt = newStaleAt;
+    }
+}
+function readFromBFCache(varyPath) {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    const isRevalidation = false;
+    return (0, _cachemap.getFromCacheMap)(// During a back/forward navigation, it doesn't matter how stale the data
+    // might be. Pass -1 instead of the actual current time to bypass
+    // staleness checks.
+    -1, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation);
+}
+function readFromBFCacheDuringRegularNavigation(now, varyPath) {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    const isRevalidation = false;
+    return (0, _cachemap.getFromCacheMap)(now, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation);
+}
+
+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=bfcache.js.map