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

package/.next/standalone/node_modules/next/dist/server/response-cache/index.js

@@ -76,6 +76,9 @@ function _export_star(from, to) {
 }
 class ResponseCache {
     constructor({ minimalMode, route, maxSize = DEFAULT_MAX_SIZE, ttl = DEFAULT_TTL_MS }){
+        // The get and revalidate batchers share pending renders across invocation
+        // IDs, including failures. Invocation IDs scope reuse of completed results in
+        // the LRU below.
         this.getBatcher = _batcher.Batcher.create({
             // Ensure on-demand revalidate doesn't block normal requests, it should be
             // safe to run an on-demand revalidate for the same key as a normal request.
@@ -147,11 +150,12 @@ class ResponseCache {
                 // With invocationID: exact match found - always a hit
                 // With TTL mode: must check expiration
                 if (context.invocationID !== undefined) {
-                    return (0, _utils.toResponseCacheEntry)(cachedItem.entry);
+                    return cachedItem.entry !== null && 'error' in cachedItem.entry ? cachedItem.entry : (0, _utils.toResponseCacheEntry)(cachedItem.entry);
                 }
-                // TTL mode: check expiration
+                // TTL entries can be reused by unrelated requests. Exclude failures so
+                // those requests can retry instead of receiving a cached error.
                 const now = Date.now();
-                if (cachedItem.expiresAt > now) {
+                if ((cachedItem.entry === null || !('error' in cachedItem.entry)) && cachedItem.expiresAt > now) {
                     return (0, _utils.toResponseCacheEntry)(cachedItem.entry);
                 }
                 // TTL expired - clean up
@@ -179,14 +183,17 @@ class ResponseCache {
             if (waitUntil) waitUntil(promise);
             return promise;
         });
-        if (this.minimal_mode && (response == null ? void 0 : response.cacheControl)) {
+        // In minimal mode, each caller with an invocation ID stores the shared
+        // failure under its own ID for reuse by related requests. Callers without
+        // an invocation ID receive the failure but do not store it in the LRU.
+        if (this.minimal_mode && response && ('error' in response ? invocationID !== undefined : response.cacheControl)) {
             const cacheKey = createCacheKey(key, invocationID);
             this.cache.set(cacheKey, {
                 entry: response,
                 expiresAt: Date.now() + this.ttl
             });
         }
-        return (0, _utils.toResponseCacheEntry)(response);
+        return response !== null && 'error' in response ? response : (0, _utils.toResponseCacheEntry)(response);
     }
     /**
    * Handles the get request for the response cache.
@@ -227,6 +234,12 @@ class ResponseCache {
             // directly lets every prefetch segment take the same fallback-shell path,
             // independent of any concurrent background upgrade.
             const incrementalResponseCacheEntry = context.isPrefetch && previousIncrementalCacheEntry === null ? await this.handleRevalidate(key, context.incrementalCache, context.isRoutePPREnabled, context.isFallback, responseGenerator, previousIncrementalCacheEntry, resolved) : await this.revalidate(key, context.incrementalCache, context.isRoutePPREnabled, context.isFallback, responseGenerator, previousIncrementalCacheEntry, resolved);
+            if (incrementalResponseCacheEntry !== null && 'error' in incrementalResponseCacheEntry && resolved) {
+                // The caller already received the stale entry. Report the background
+                // failure here, as the catch below does for a thrown error.
+                console.error(incrementalResponseCacheEntry.error);
+                return null;
+            }
             // Handle null response
             if (!incrementalResponseCacheEntry) {
                 // Remove the cache item if it was set so we don't use it again.
@@ -273,6 +286,7 @@ class ResponseCache {
         });
     }
     async handleRevalidate(key, incrementalCache, isRoutePPREnabled, isFallback, responseGenerator, previousIncrementalCacheEntry, hasResolved) {
+        let failure;
         try {
             // Generate the response cache entry using the response generator.
             const responseCacheEntry = await responseGenerator({
@@ -283,38 +297,46 @@ class ResponseCache {
             if (!responseCacheEntry) {
                 return null;
             }
-            // Convert the response cache entry to an incremental response cache entry.
-            const incrementalResponseCacheEntry = await (0, _utils.fromResponseCacheEntry)({
-                ...responseCacheEntry,
-                isMiss: !previousIncrementalCacheEntry
-            });
-            // We want to persist the result only if it has a cache control value
-            // defined. The minimal mode LRU write is handled in get() so that
-            // every caller — including batched invocations — populates the cache.
-            if (incrementalResponseCacheEntry.cacheControl && !this.minimal_mode) {
-                await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
-                    ...this.getCacheContext(isRoutePPREnabled, isFallback),
-                    cacheControl: incrementalResponseCacheEntry.cacheControl
+            if ('error' in responseCacheEntry) {
+                failure = responseCacheEntry;
+            } else {
+                // Convert the response cache entry to an incremental response cache entry.
+                const incrementalResponseCacheEntry = await (0, _utils.fromResponseCacheEntry)({
+                    ...responseCacheEntry,
+                    isMiss: !previousIncrementalCacheEntry
                 });
+                // We want to persist the result only if it has a cache control value
+                // defined. The minimal mode LRU write is handled in get() so that every
+                // caller, including batched invocations, populates the cache.
+                if (incrementalResponseCacheEntry.cacheControl && !this.minimal_mode) {
+                    await incrementalCache.set(key, incrementalResponseCacheEntry.value, {
+                        ...this.getCacheContext(isRoutePPREnabled, isFallback),
+                        cacheControl: incrementalResponseCacheEntry.cacheControl
+                    });
+                }
+                return incrementalResponseCacheEntry;
             }
-            return incrementalResponseCacheEntry;
         } catch (err) {
-            // When a path is erroring we automatically re-set the existing cache
-            // with new revalidate and expire times to prevent non-stop retrying.
-            if (previousIncrementalCacheEntry == null ? void 0 : previousIncrementalCacheEntry.cacheControl) {
-                const revalidate = Math.min(Math.max(previousIncrementalCacheEntry.cacheControl.revalidate || 3, 3), 30);
-                const expire = previousIncrementalCacheEntry.cacheControl.expire === undefined ? undefined : Math.max(revalidate + 3, previousIncrementalCacheEntry.cacheControl.expire);
-                await incrementalCache.set(key, previousIncrementalCacheEntry.value, {
-                    ...this.getCacheContext(isRoutePPREnabled, isFallback),
-                    cacheControl: {
-                        revalidate: revalidate,
-                        expire: expire
-                    }
-                });
-            }
-            // We haven't resolved yet, so let's throw to indicate an error.
+            await this.retainPreviousCacheEntry(key, incrementalCache, isRoutePPREnabled, isFallback, previousIncrementalCacheEntry);
             throw err;
         }
+        await this.retainPreviousCacheEntry(key, incrementalCache, isRoutePPREnabled, isFallback, previousIncrementalCacheEntry);
+        return failure;
+    }
+    // Retain the previous successful value and delay retries after revalidation
+    // fails.
+    async retainPreviousCacheEntry(key, incrementalCache, isRoutePPREnabled, isFallback, previousIncrementalCacheEntry) {
+        if (previousIncrementalCacheEntry == null ? void 0 : previousIncrementalCacheEntry.cacheControl) {
+            const revalidate = Math.min(Math.max(previousIncrementalCacheEntry.cacheControl.revalidate || 3, 3), 30);
+            const expire = previousIncrementalCacheEntry.cacheControl.expire === undefined ? undefined : Math.max(revalidate + 3, previousIncrementalCacheEntry.cacheControl.expire);
+            await incrementalCache.set(key, previousIncrementalCacheEntry.value, {
+                ...this.getCacheContext(isRoutePPREnabled, isFallback),
+                cacheControl: {
+                    revalidate: revalidate,
+                    expire: expire
+                }
+            });
+        }
     }
     getCacheContext(isRoutePPREnabled, isFallback) {
         if (this.route === 'image') {

package/.next/standalone/node_modules/next/dist/server/response-cache/utils.js

@@ -91,11 +91,7 @@ function routeKindToIncrementalCacheKind(routeKind) {
             return _types.IncrementalCacheKind.APP_ROUTE;
         case _routekind.RouteKind.PAGES_API:
             // Pages Router API routes are not cached in the incremental cache.
-            throw Object.defineProperty(new Error(`Unexpected route kind ${routeKind}`), "__NEXT_ERROR_CODE", {
-                value: "E64",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Unexpected route kind ${routeKind}`);
         default:
             return routeKind;
     }

package/.next/standalone/node_modules/next/dist/server/response-cache/web.js

@@ -11,7 +11,7 @@ Object.defineProperty(exports, /**
         return WebResponseCache;
     }
 });
-const _detachedpromise = require("../../lib/detached-promise");
+const _promisewithresolvers = require("../../shared/lib/promise-with-resolvers");
 class WebResponseCache {
     constructor(minimalMode){
         this.pendingResponses = new Map();
@@ -29,7 +29,7 @@ class WebResponseCache {
         if (pendingResponse) {
             return pendingResponse;
         }
-        const { promise, resolve: resolver, reject: rejecter } = new _detachedpromise.DetachedPromise();
+        const { promise, resolve: resolver, reject: rejecter } = (0, _promisewithresolvers.createPromiseWithResolvers)();
         if (pendingResponseKey) {
             this.pendingResponses.set(pendingResponseKey, promise);
         }
@@ -60,6 +60,9 @@ class WebResponseCache {
                 const cacheEntry = await responseGenerator({
                     hasResolved
                 });
+                if (cacheEntry !== null && 'error' in cacheEntry) {
+                    throw cacheEntry.error;
+                }
                 const resolveValue = cacheEntry === null ? null : {
                     ...cacheEntry,
                     isMiss: true

package/.next/standalone/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/.next/standalone/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/.next/standalone/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/.next/standalone/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/.next/standalone/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/.next/standalone/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/.next/standalone/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/.next/standalone/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