@sifxprime/krouter 0.5.166 → 0.5.167

package/app/node_modules/next/dist/server/resume-data-cache/cache-store.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    FALLBACK_PARAMS: null,
+    RUNTIME_DATA: null,
+    SESSION_DATA: null,
     parseUseCacheCacheStore: null,
     serializeUseCacheCacheStore: null
 });
@@ -13,6 +16,15 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    FALLBACK_PARAMS: function() {
+        return FALLBACK_PARAMS;
+    },
+    RUNTIME_DATA: function() {
+        return RUNTIME_DATA;
+    },
+    SESSION_DATA: function() {
+        return SESSION_DATA;
+    },
     parseUseCacheCacheStore: function() {
         return parseUseCacheCacheStore;
     },
@@ -22,6 +34,9 @@ _export(exports, {
 });
 const _encryptionutils = require("../app-render/encryption-utils");
 const _constants = require("../use-cache/constants");
+const FALLBACK_PARAMS = Symbol.for('next.resume-data-cache.fallback-params');
+const RUNTIME_DATA = Symbol.for('next.resume-data-cache.runtime-data');
+const SESSION_DATA = Symbol.for('next.resume-data-cache.session-data');
 function parseUseCacheCacheStore(entries) {
     const store = new Map();
     for (const [key, { entry, hasExplicitRevalidate, hasExplicitExpire, readRootParamNames }] of entries){
@@ -56,6 +71,9 @@ function parseUseCacheCacheStore(entries) {
 }
 async function serializeUseCacheCacheStore(entries, isCacheComponentsEnabled) {
     return Promise.all(Array.from(entries).map(([key, value])=>{
+        if (value === FALLBACK_PARAMS || value === RUNTIME_DATA || value === SESSION_DATA) {
+            return null;
+        }
         return value.then(async ({ entry, hasExplicitRevalidate, hasExplicitExpire, readRootParamNames })=>{
             if (isCacheComponentsEnabled && (entry.revalidate === 0 || entry.expire < _constants.MIN_PRERENDERABLE_EXPIRE)) {
                 // The entry was omitted from the prerender result, and subsequently

package/app/node_modules/next/dist/server/resume-data-cache/resume-data-cache.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     createPrerenderResumeDataCache: null,
     createRenderResumeDataCache: null,
+    deflateResumeDataCache: null,
     stringifyResumeDataCache: null
 });
 function _export(target, all) {
@@ -20,6 +21,9 @@ _export(exports, {
     createRenderResumeDataCache: function() {
         return createRenderResumeDataCache;
     },
+    deflateResumeDataCache: function() {
+        return deflateResumeDataCache;
+    },
     stringifyResumeDataCache: function() {
         return stringifyResumeDataCache;
     }
@@ -28,26 +32,31 @@ const _invarianterror = require("../../shared/lib/invariant-error");
 const _cachestore = require("./cache-store");
 async function stringifyResumeDataCache(resumeDataCache, isCacheComponentsEnabled) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`stringifyResumeDataCache` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E602",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('`stringifyResumeDataCache` should not be called in edge runtime.');
+    }
+    if (resumeDataCache.fetch.size === 0 && resumeDataCache.cache.size === 0) {
+        return 'null';
+    }
+    const json = {
+        store: {
+            fetch: Object.fromEntries(resumeDataCache.fetch),
+            cache: Object.fromEntries((await (0, _cachestore.serializeUseCacheCacheStore)(resumeDataCache.cache.entries(), isCacheComponentsEnabled)).filter((entry)=>entry !== null)),
+            encryptedBoundArgs: Object.fromEntries(resumeDataCache.encryptedBoundArgs)
+        }
+    };
+    return JSON.stringify(json);
+}
+function deflateResumeDataCache(serializedResumeDataCache) {
+    if (process.env.NEXT_RUNTIME === 'edge') {
+        throw new _invarianterror.InvariantError('`deflateResumeDataCache` should not be called in edge runtime.');
     } else {
-        if (resumeDataCache.fetch.size === 0 && resumeDataCache.cache.size === 0) {
-            return 'null';
+        if (serializedResumeDataCache === 'null') {
+            return serializedResumeDataCache;
         }
-        const json = {
-            store: {
-                fetch: Object.fromEntries(Array.from(resumeDataCache.fetch.entries())),
-                cache: Object.fromEntries((await (0, _cachestore.serializeUseCacheCacheStore)(resumeDataCache.cache.entries(), isCacheComponentsEnabled)).filter((entry)=>entry !== null)),
-                encryptedBoundArgs: Object.fromEntries(Array.from(resumeDataCache.encryptedBoundArgs.entries()))
-            }
-        };
-        // Compress the JSON string using zlib. As the data we already want to
-        // decompress is in memory, we use the synchronous deflateSync function.
+        // Compress the JSON string using zlib. As the data is already in memory,
+        // we use the synchronous deflateSync function.
         const { deflateSync } = require('node:zlib');
-        return deflateSync(JSON.stringify(json)).toString('base64');
+        return deflateSync(serializedResumeDataCache).toString('base64');
     }
 }
 function createPrerenderResumeDataCache(source) {
@@ -58,8 +67,7 @@ function createPrerenderResumeDataCache(source) {
             fetch: new Map(source.fetch),
             encryptedBoundArgs: new Map(source.encryptedBoundArgs),
             decryptedBoundArgs: new Map(source.decryptedBoundArgs),
-            imageResponses: new Map(source.imageResponses),
-            dynamicCacheKeys: source.dynamicCacheKeys ? new Set(source.dynamicCacheKeys) : new Set()
+            imageResponses: new Map(source.imageResponses)
         };
     } else {
         return {
@@ -68,18 +76,13 @@ function createPrerenderResumeDataCache(source) {
             fetch: new Map(),
             encryptedBoundArgs: new Map(),
             decryptedBoundArgs: new Map(),
-            imageResponses: new Map(),
-            dynamicCacheKeys: new Set()
+            imageResponses: new Map()
         };
     }
 }
-function createRenderResumeDataCache(resumeDataCacheOrPersistedCache, maxPostponedStateSizeBytes) {
+function createRenderResumeDataCache(resumeDataCacheOrPersistedCache, maxPostponedStateSizeBytes, disableResumeDataCacheCompression = false) {
     if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`createRenderResumeDataCache` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E556",
-            enumerable: false,
-            configurable: true
-        });
+        throw new _invarianterror.InvariantError('`createRenderResumeDataCache` should not be called in edge runtime.');
     } else {
         if (typeof resumeDataCacheOrPersistedCache !== 'string') {
             // If the cache is already read-only, return it directly. Otherwise we
@@ -104,30 +107,29 @@ function createRenderResumeDataCache(resumeDataCacheOrPersistedCache, maxPostpon
                 imageResponses: new Map()
             };
         }
-        // This should be a compressed string. Let's decompress it using zlib.
-        // As the data we already want to decompress is in memory, we use the
-        // synchronous inflateSync function.
-        const { inflateSync } = require('node:zlib');
-        // Limit decompressed size to prevent zipbomb attacks. This is 5x the
-        // configured maxPostponedStateSize, allowing reasonable compression
-        // ratios while preventing extreme decompression bombs.
-        // Default is 500MB (5x the default 100MB compressed limit).
-        const maxDecompressedSize = maxPostponedStateSizeBytes ? maxPostponedStateSizeBytes * 5 : 500 * 1024 * 1024;
-        let json;
-        try {
-            json = JSON.parse(inflateSync(Buffer.from(resumeDataCacheOrPersistedCache, 'base64'), {
-                maxOutputLength: maxDecompressedSize
-            }).toString('utf-8'));
-        } catch (err) {
-            if (err instanceof RangeError && err.code === 'ERR_BUFFER_TOO_LARGE') {
-                throw Object.defineProperty(new Error(`Decompressed resume data cache exceeded ${maxDecompressedSize} byte limit`), "__NEXT_ERROR_CODE", {
-                    value: "E976",
-                    enumerable: false,
-                    configurable: true
-                });
+        let serializedResumeDataCache = resumeDataCacheOrPersistedCache;
+        if (!disableResumeDataCacheCompression) {
+            // This should be a compressed string. Let's decompress it using zlib.
+            // As the data we already want to decompress is in memory, we use the
+            // synchronous inflateSync function.
+            const { inflateSync } = require('node:zlib');
+            // Limit decompressed size to prevent zipbomb attacks. This is 5x the
+            // configured maxPostponedStateSize, allowing reasonable compression
+            // ratios while preventing extreme decompression bombs.
+            // Default is 500MB (5x the default 100MB compressed limit).
+            const maxDecompressedSize = maxPostponedStateSizeBytes ? maxPostponedStateSizeBytes * 5 : 500 * 1024 * 1024;
+            try {
+                serializedResumeDataCache = inflateSync(Buffer.from(serializedResumeDataCache, 'base64'), {
+                    maxOutputLength: maxDecompressedSize
+                }).toString('utf-8');
+            } catch (err) {
+                if (err instanceof RangeError && err.code === 'ERR_BUFFER_TOO_LARGE') {
+                    throw new Error(`Decompressed resume data cache exceeded ${maxDecompressedSize} byte limit`);
+                }
+                throw err;
             }
-            throw err;
         }
+        const json = JSON.parse(serializedResumeDataCache);
         return {
             mutable: false,
             cache: (0, _cachestore.parseUseCacheCacheStore)(Object.entries(json.store.cache)),

package/app/node_modules/next/dist/server/revalidation-utils.js

@@ -38,9 +38,11 @@ async function withExecuteRevalidates(store, callback) {
 }
 function cloneRevalidationState(store) {
     return {
-        pendingRevalidatedTags: store.pendingRevalidatedTags ? [
-            ...store.pendingRevalidatedTags
-        ] : [],
+        // revalidateTag updates revalidatedAt in place when the tag/profile already
+        // exists, so snapshot the items as well as the array.
+        pendingRevalidatedTags: store.pendingRevalidatedTags ? store.pendingRevalidatedTags.map((item)=>({
+                ...item
+            })) : [],
         pendingRevalidates: {
             ...store.pendingRevalidates
         },
@@ -50,15 +52,19 @@ function cloneRevalidationState(store) {
     };
 }
 function diffRevalidationState(prev, curr) {
-    const prevTagsWithProfile = new Set(prev.pendingRevalidatedTags.map((item)=>{
+    const prevTagsWithProfile = new Map(prev.pendingRevalidatedTags.map((item)=>{
         const profileKey = typeof item.profile === 'object' ? JSON.stringify(item.profile) : item.profile || '';
-        return `${item.tag}:${profileKey}`;
+        return [
+            `${item.tag}:${profileKey}`,
+            item.revalidatedAt
+        ];
     }));
     const prevRevalidateWrites = new Set(prev.pendingRevalidateWrites);
     return {
         pendingRevalidatedTags: curr.pendingRevalidatedTags.filter((item)=>{
             const profileKey = typeof item.profile === 'object' ? JSON.stringify(item.profile) : item.profile || '';
-            return !prevTagsWithProfile.has(`${item.tag}:${profileKey}`);
+            const previousRevalidatedAt = prevTagsWithProfile.get(`${item.tag}:${profileKey}`);
+            return previousRevalidatedAt === undefined || item.revalidatedAt > previousRevalidatedAt;
         }),
         pendingRevalidates: Object.fromEntries(Object.entries(curr.pendingRevalidates).filter(([key])=>!(key in prev.pendingRevalidates))),
         pendingRevalidateWrites: curr.pendingRevalidateWrites.filter((promise)=>!prevRevalidateWrites.has(promise))
@@ -68,7 +74,7 @@ async function revalidateTags(tagsWithProfile, incrementalCache, workStore) {
     if (tagsWithProfile.length === 0) {
         return;
     }
-    const handlers = (0, _handlers.getCacheHandlers)();
+    const handlers = (0, _handlers.getCacheHandlers)() ?? [];
     const promises = [];
     // Group tags by profile for batch processing
     const tagsByProfile = new Map();
@@ -109,11 +115,7 @@ async function revalidateTags(tagsWithProfile, incrementalCache, workStore) {
                 // Profile is a string key, look it up in workStore
                 cacheLife = workStore == null ? void 0 : workStore.cacheLifeProfiles[profile];
                 if (!cacheLife) {
-                    throw Object.defineProperty(new Error(`Invalid profile provided "${profile}" must be configured under cacheLife in next.config or be "max"`), "__NEXT_ERROR_CODE", {
-                        value: "E873",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Invalid profile provided "${profile}" must be configured under cacheLife in next.config or be "max"`);
                 }
             }
             if (cacheLife) {
@@ -124,7 +126,7 @@ async function revalidateTags(tagsWithProfile, incrementalCache, workStore) {
         }
         // If profile is not found and not 'max', durations will be undefined
         // which will trigger immediate expiration in the cache handler
-        for (const handler of handlers || []){
+        for (const handler of handlers){
             if (profile) {
                 promises.push(handler.updateTags == null ? void 0 : handler.updateTags.call(handler, tagsForProfile, durations));
             } else {

package/app/node_modules/next/dist/server/route-modules/app-page/dev-render-context.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createDevRenderContext", {
+    enumerable: true,
+    get: function() {
+        return createDevRenderContext;
+    }
+});
+const _requestmeta = require("../../request-meta");
+function createDevRenderContext(req, hmrCacheFallback) {
+    if (!process.env.__NEXT_DEV_SERVER) {
+        return undefined;
+    }
+    const { serverComponentsHmrCache, hmrRefreshHash } = (0, _requestmeta.getRequestMeta)(req);
+    return {
+        serverComponentsHmrCache: serverComponentsHmrCache ?? hmrCacheFallback,
+        hmrRefreshHash
+    };
+}
+
+//# sourceMappingURL=dev-render-context.js.map

package/app/node_modules/next/dist/server/route-modules/app-page/helpers/prerender-manifest-matcher.js

@@ -8,7 +8,6 @@ Object.defineProperty(exports, "PrerenderManifestMatcher", {
         return PrerenderManifestMatcher;
     }
 });
-const _routematcher = require("../../../../shared/lib/router/utils/route-matcher");
 const _routeregex = require("../../../../shared/lib/router/utils/route-regex");
 class PrerenderManifestMatcher {
     constructor(pathname, prerenderManifest){
@@ -34,10 +33,12 @@ class PrerenderManifestMatcher {
         for (const matcher of this.matchers){
             // Lazily create the matcher, this is only done once per matcher.
             if (!matcher.matcher) {
-                matcher.matcher = (0, _routematcher.getRouteMatcher)((0, _routeregex.getRouteRegex)(matcher.source));
+                // The pathname has already been decoded for manifest lookup. We only
+                // need to check its structure here; extracting captures would decode
+                // route parameters again and reject literal percent signs.
+                matcher.matcher = (0, _routeregex.getRouteRegex)(matcher.source).re;
             }
-            const match = matcher.matcher(pathname);
-            if (match) {
+            if (matcher.matcher.test(pathname)) {
                 return {
                     source: matcher.source,
                     route: matcher.route

package/app/node_modules/next/dist/server/route-modules/app-page/module.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     AppPageRouteModule: null,
     default: null,
+    prerenderToHTMLOrFlight: null,
     renderToHTMLOrFlight: null,
     vendored: null
 });
@@ -21,6 +22,9 @@ _export(exports, {
     default: function() {
         return _default;
     },
+    prerenderToHTMLOrFlight: function() {
+        return _apprender.prerenderToHTMLOrFlight;
+    },
     renderToHTMLOrFlight: function() {
         return _apprender.renderToHTMLOrFlight;
     },
@@ -128,7 +132,15 @@ class AppPageRouteModule extends _routemodule.RouteModule {
         (0, _normalizerequesturl.normalizeAppPageRequestUrl)(req, parsedUrl.pathname || '/');
     }
     render(req, res, context) {
-        return (0, _apprender.renderToHTMLOrFlight)(req, res, context.page, context.query, context.fallbackRouteParams, context.renderOpts, context.serverComponentsHmrCache, context.sharedContext);
+        return (0, _apprender.renderToHTMLOrFlight)(req, res, context.page, context.query, context.fallbackRouteParams, // HEAD responses do not consume the render stream, so they cannot
+        // establish a new status for the dev indicator.
+        process.env.__NEXT_DEV_SERVER && req.method === 'HEAD' ? {
+            ...context.renderOpts,
+            setIsrStatus: undefined
+        } : context.renderOpts, context.dev, context.sharedContext, context.routeMatch, context.parsedRequestHeaders);
+    }
+    prerender(req, res, context) {
+        return (0, _apprender.prerenderToHTMLOrFlight)(req, res, context.page, context.query, context.fallbackRouteParams, context.renderOpts, undefined, context.sharedContext, context.routeMatch, context.parsedRequestHeaders);
     }
     /**
    * Worker entry point for dev Cache Components dev validation. The dev

package/app/node_modules/next/dist/server/route-modules/app-page/module.render.js

@@ -2,23 +2,38 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "lazyRenderAppPage", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    lazyPrerenderAppPage: null,
+    lazyRenderAppPage: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    lazyPrerenderAppPage: function() {
+        return lazyPrerenderAppPage;
+    },
+    lazyRenderAppPage: function() {
         return lazyRenderAppPage;
     }
 });
-const lazyRenderAppPage = (...args)=>{
+function getAppPageModule() {
     if (process.env.NEXT_MINIMAL) {
-        throw Object.defineProperty(new Error("Can't use lazyRenderAppPage in minimal mode"), "__NEXT_ERROR_CODE", {
-            value: "E256",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error("Can't use lazyRenderAppPage in minimal mode");
     } else {
-        const render = require('./module.compiled').renderToHTMLOrFlight;
-        return render(...args);
+        return require('./module.compiled');
     }
+}
+const lazyRenderAppPage = (...args)=>{
+    const render = getAppPageModule().renderToHTMLOrFlight;
+    return render(...args);
+};
+const lazyPrerenderAppPage = (...args)=>{
+    const prerender = getAppPageModule().prerenderToHTMLOrFlight;
+    return prerender(...args);
 };
 
 //# sourceMappingURL=module.render.js.map

package/app/node_modules/next/dist/server/route-modules/app-page/parse-request-headers.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "parseRequestHeaders", {
+    enumerable: true,
+    get: function() {
+        return parseRequestHeaders;
+    }
+});
+const _approuterheaders = require("../../../client/components/app-router-headers");
+const _isrscrequest = require("../../lib/is-rsc-request");
+const _getscriptnoncefromheader = require("../../app-render/get-script-nonce-from-header");
+const _parseandvalidateflightrouterstate = require("../../app-render/parse-and-validate-flight-router-state");
+const _serverutils = require("../../server-utils");
+function parseRequestHeaders(headers, options) {
+    const isRSCRequest = (0, _isrscrequest.isRSCRequestHeader)(headers[_approuterheaders.RSC_HEADER]);
+    // runtime prefetch requests are *not* treated as prefetch requests
+    // (TODO: this is confusing, we should refactor this to express this better)
+    const isPrefetchRequest = isRSCRequest && headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '1';
+    const isAppShellPrefetchRequest = isRSCRequest && headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '3';
+    // App Shell prefetches are a subtype of runtime prefetch — same code path,
+    // but with less resolved content (omitting link data)
+    const isRuntimePrefetchRequest = isRSCRequest && (headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '2' || isAppShellPrefetchRequest);
+    const isHmrRefresh = headers[_approuterheaders.NEXT_HMR_REFRESH_HEADER] !== undefined;
+    const shouldProvideFlightRouterState = isRSCRequest && (!isPrefetchRequest || !options.isRoutePPREnabled);
+    const flightRouterState = shouldProvideFlightRouterState ? (0, _parseandvalidateflightrouterstate.parseAndValidateFlightRouterState)(headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]) : undefined;
+    // Checks if this is a prefetch of the Route Tree by the Segment Cache
+    const isRouteTreePrefetchRequest = isRSCRequest && headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER] === '/_tree';
+    const csp = headers['content-security-policy'] || headers['content-security-policy-report-only'];
+    const nonce = typeof csp === 'string' ? (0, _getscriptnoncefromheader.getScriptNonceFromHeader)(csp) : undefined;
+    const previouslyRevalidatedTags = (0, _serverutils.getPreviouslyRevalidatedTags)(headers, options.previewModeId);
+    let requestId;
+    let htmlRequestId;
+    if (process.env.__NEXT_DEV_SERVER) {
+        // The request IDs are only used for the dev server to send debug
+        // information to the matching client (identified by the HTML request ID
+        // that was sent to the client with the HTML document) for the current
+        // request (identified by the request ID, as defined by the client).
+        requestId = typeof headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] === 'string' ? headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] : undefined;
+        htmlRequestId = typeof headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] === 'string' ? headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] : undefined;
+    }
+    return {
+        flightRouterState,
+        isPrefetchRequest,
+        isRuntimePrefetchRequest,
+        isAppShellPrefetchRequest,
+        isRouteTreePrefetchRequest,
+        isHmrRefresh,
+        isRSCRequest,
+        nonce,
+        previouslyRevalidatedTags,
+        requestId,
+        htmlRequestId
+    };
+}
+
+//# sourceMappingURL=parse-request-headers.js.map

package/app/node_modules/next/dist/server/route-modules/app-page/vendored/rsc/entrypoints.js

@@ -100,11 +100,7 @@ function getAltProxyForBindingsDEV(type, pkg) {
         const altPkg = pkg.replace(new RegExp(type, 'gi'), altType.toLowerCase());
         return new Proxy({}, {
             get (_, prop) {
-                throw Object.defineProperty(new Error(`Expected to use ${type} bindings (${pkg}) for React but the current process is referencing '${prop}' from the ${altType} bindings (${altPkg}). This is likely a bug in our integration of the Next.js server runtime.`), "__NEXT_ERROR_CODE", {
-                    value: "E253",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Expected to use ${type} bindings (${pkg}) for React but the current process is referencing '${prop}' from the ${altType} bindings (${altPkg}). This is likely a bug in our integration of the Next.js server runtime.`);
             }
         });
     }

package/app/node_modules/next/dist/server/route-modules/app-page/vendored/ssr/entrypoints.js

@@ -97,11 +97,7 @@ function getAltProxyForBindingsDEV(type, pkg) {
         const altPkg = pkg.replace(new RegExp(type, 'gi'), altType.toLowerCase());
         return new Proxy({}, {
             get (_, prop) {
-                throw Object.defineProperty(new Error(`Expected to use ${type} bindings (${pkg}) for React but the current process is referencing '${prop}' from the ${altType} bindings (${altPkg}). This is likely a bug in our integration of the Next.js server runtime.`), "__NEXT_ERROR_CODE", {
-                    value: "E253",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Expected to use ${type} bindings (${pkg}) for React but the current process is referencing '${prop}' from the ${altType} bindings (${altPkg}). This is likely a bug in our integration of the Next.js server runtime.`);
             }
         });
     }

package/app/node_modules/next/dist/server/route-modules/pages/module.render.js

@@ -10,11 +10,7 @@ Object.defineProperty(exports, "lazyRenderPagesPage", {
 });
 const lazyRenderPagesPage = (...args)=>{
     if (process.env.NEXT_MINIMAL) {
-        throw Object.defineProperty(new Error("Can't use lazyRenderPagesPage in minimal mode"), "__NEXT_ERROR_CODE", {
-            value: "E272",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error("Can't use lazyRenderPagesPage in minimal mode");
     } else {
         const render = require('./module.compiled').renderToHTML;
         return render(...args);

package/app/node_modules/next/dist/server/route-modules/pages/pages-handler.js

@@ -86,7 +86,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                 res.end('This page could not be found');
             }
         };
-        const { buildId, query, params, parsedUrl, originalQuery, originalPathname, buildManifest, fallbackBuildManifest, nextFontManifest, serverFilesManifest, reactLoadableManifest, prerenderManifest, isDraftMode, isOnDemandRevalidate, revalidateOnlyGenerated, locale, locales, defaultLocale, routerServerContext, nextConfig, resolvedPathname, encodedResolvedPathname, deploymentId, clientAssetToken } = prepareResult;
+        const { buildId, query, params, parsedUrl, originalQuery, originalPathname, buildManifest, fallbackBuildManifest, nextFontManifest, serverFilesManifest, reactLoadableManifest, prerenderManifest, previewProps, isDraftMode, isOnDemandRevalidate, revalidateOnlyGenerated, locale, locales, defaultLocale, routerServerContext, nextConfig, resolvedPathname, encodedResolvedPathname, deploymentId, clientAssetToken } = prepareResult;
         const isExperimentalCompile = serverFilesManifest == null ? void 0 : (_serverFilesManifest_config = serverFilesManifest.config) == null ? void 0 : (_serverFilesManifest_config_experimental = _serverFilesManifest_config.experimental) == null ? void 0 : _serverFilesManifest_config_experimental.isExperimentalCompile;
         const hasServerProps = Boolean(getServerSideProps);
         const hasStaticProps = Boolean(getStaticProps);
@@ -182,8 +182,8 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                                 buildManifest: isFallbackError ? fallbackBuildManifest : buildManifest,
                                 nextFontManifest,
                                 reactLoadableManifest,
-                                assetPrefix: nextConfig.assetPrefix,
-                                previewProps: prerenderManifest.preview,
+                                assetPrefix: routeModule.getAssetPrefixForRender(routerServerContext, nextConfig.assetPrefix),
+                                previewProps,
                                 images: nextConfig.images,
                                 nextConfigOutput: nextConfig.output,
                                 optimizeCss: Boolean(nextConfig.experimental.optimizeCss),
@@ -295,9 +295,12 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                         isFallback: true,
                         isRoutePPREnabled: false,
                         isOnDemandRevalidate: false,
-                        incrementalCache: await routeModule.getIncrementalCache(req, nextConfig, prerenderManifest, isMinimalMode),
+                        incrementalCache: await routeModule.getIncrementalCache(req, nextConfig, previewProps, prerenderManifest, isMinimalMode),
                         waitUntil: ctx.waitUntil
                     });
+                    if (fallbackResponse !== null && 'error' in fallbackResponse) {
+                        throw fallbackResponse.error;
+                    }
                     if (fallbackResponse) {
                         // Remove the cache control from the response to prevent it from being
                         // used in the surrounding cache.
@@ -346,9 +349,13 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                     revalidateOnlyGenerated,
                     waitUntil: ctx.waitUntil,
                     responseGenerator: responseGenerator,
+                    previewProps,
                     prerenderManifest,
                     isMinimalMode
                 });
+                if (result !== null && 'error' in result) {
+                    throw result.error;
+                }
                 // if we got a cache hit this wasn't an ISR fallback
                 // but it wasn't generated during build so isn't in the
                 // prerender-manifest
@@ -386,11 +393,7 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                     // a number, use it.
                     if (typeof result.cacheControl.revalidate === 'number') {
                         if (result.cacheControl.revalidate < 1) {
-                            throw Object.defineProperty(new Error(`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`), "__NEXT_ERROR_CODE", {
-                                value: "E22",
-                                enumerable: false,
-                                configurable: true
-                            });
+                            throw new Error(`Invalid revalidate configuration provided: ${result.cacheControl.revalidate} < 1`);
                         }
                         cacheControl = {
                             revalidate: result.cacheControl.revalidate,
@@ -462,15 +465,16 @@ const getHandler = ({ srcPage: originalSrcPage, config, userland, routeModule, i
                     }
                 }
                 if (result.value.kind !== _responsecache.CachedRouteKind.PAGES) {
-                    throw Object.defineProperty(new Error(`Invariant: received non-pages cache entry in pages handler`), "__NEXT_ERROR_CODE", {
-                        value: "E695",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Invariant: received non-pages cache entry in pages handler`);
                 }
-                // In dev, we should not cache pages for any reason.
+                // Documents and data responses must not be stored in development.
+                // Browsers reuse a stored response for a history navigation without
+                // revalidating it, so a back navigation would restore a page from
+                // before the latest edit. Static assets never reach this code. They
+                // keep a revalidatable `Cache-Control`, so the browser caches them
+                // between page loads.
                 if (routeModule.isDev) {
-                    res.setHeader('Cache-Control', 'no-cache, must-revalidate');
+                    res.setHeader('Cache-Control', 'no-store');
                 }
                 // Draft mode should never be cached
                 if (isDraftMode) {