failproofai 0.0.10 → 0.0.11-beta.10

package/.next/standalone/node_modules/next/dist/server/image-optimizer.js

@@ -1010,14 +1010,15 @@ async function fetchExternalImage(href, dangerouslyAllowLocalIP, maximumResponse
         etag
     };
 }
-async function fetchInternalImage(href, _req, _res, handleRequest) {
+async function fetchInternalImage(href, _req, _res, maximumResponseBody, handleRequest) {
     try {
         // Coerce HEAD to GET to avoid issues with the image optimizer
         const method = !_req.method || _req.method === 'HEAD' ? 'GET' : _req.method;
         const mocked = (0, _mockrequest.createRequestResponseMocks)({
             url: href,
             method,
-            socket: _req.socket
+            socket: _req.socket,
+            maximumResponseBody
         });
         await handleRequest(mocked.req, mocked.res, _url.default.parse(href, true));
         await mocked.res.hasStreamed;
@@ -1029,6 +1030,14 @@ async function fetchInternalImage(href, _req, _res, handleRequest) {
                 configurable: true
             });
         }
+        if (mocked.res.buffers.length === 0) {
+            _log.error('internal image response is empty for', href);
+            throw Object.defineProperty(new ImageError(400, '"url" parameter is valid but internal response is invalid'), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
         const buffer = Buffer.concat(mocked.res.buffers);
         const contentType = mocked.res.getHeader('Content-Type');
         const cacheControl = mocked.res.getHeader('Cache-Control');
@@ -1040,6 +1049,17 @@ async function fetchInternalImage(href, _req, _res, handleRequest) {
             etag
         };
     } catch (err) {
+        if (err instanceof ImageError) {
+            throw err;
+        }
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'ERR_MAX_BODY_SIZE_EXCEEDED') {
+            _log.error('internal image response exceeded maximum size for', href);
+            throw Object.defineProperty(new ImageError(413, '"url" parameter is valid but internal response is invalid'), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
         _log.error('upstream image response failed for', href, err);
         throw Object.defineProperty(new ImageError(500, '"url" parameter is valid but upstream response is invalid'), "__NEXT_ERROR_CODE", {
             value: "E394",

package/.next/standalone/node_modules/next/dist/server/lib/app-info-log.js

@@ -85,7 +85,7 @@ function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
     if (parts.length > 0) {
         versionSuffix = ` (${parts.join(', ')})`;
     }
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.2.4"}`))}${versionSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.2.9"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }

package/.next/standalone/node_modules/next/dist/server/lib/encode-cache-tag.js

@@ -0,0 +1,45 @@
+/**
+ * Percent-encode every character outside printable ASCII so a tag value can be
+ * safely serialized as part of the `x-next-cache-tags` HTTP header.
+ *
+ * Node's `validateHeaderValue` rejects any code unit outside `\t\x20-\x7e`, so
+ * a matched route path or user-supplied tag containing a non-ASCII character
+ * (Hebrew, Arabic, Chinese, emoji, …) would otherwise throw `ERR_INVALID_CHAR`
+ * and crash ISR on every affected request.
+ *
+ * This is applied at the public boundaries — tag construction
+ * (`getImplicitTags`, `validateTags`) and invalidation input (`revalidatePath`,
+ * `revalidateTag`, `updateTag`) — so storage, comparison, and the wire all see
+ * the same canonical ASCII-safe form.
+ *
+ * The character class `[\t\x20-\x7e]` mirrors Node's `validHdrChars` table —
+ * `\t` plus printable ASCII through `~`. Anything outside that is rejected
+ * by `validateHeaderValue`, so we encode runs of those characters and leave
+ * everything else (`,`, `/`, `%`, `[`, `]`, `_`, `-`, `\t`, …) byte-for-byte
+ * unchanged. This preserves the comma-separated header format and the
+ * dynamic-segment markers in derived tags (`_N_T_/[slug]/page`).
+ *
+ * Properties:
+ * - Fast-path: input that already fits the validation class is returned
+ *   unchanged. This makes the encoder idempotent on already-encoded `%xx`
+ *   sequences.
+ * - Matches *runs* of out-of-class code units so surrogate pairs (e.g. an
+ *   emoji) are handed to `encodeURIComponent` as a complete code point — a
+ *   per-code-unit regex would split the pair and throw `URIError`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "encodeCacheTag", {
+    enumerable: true,
+    get: function() {
+        return encodeCacheTag;
+    }
+});
+const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
+const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+function encodeCacheTag(tag) {
+    return OUT_OF_CLASS_CHAR.test(tag) ? tag.replace(OUT_OF_CLASS_RUN, (run)=>encodeURIComponent(run)) : tag;
+}
+
+//# sourceMappingURL=encode-cache-tag.js.map

package/.next/standalone/node_modules/next/dist/server/lib/implicit-tags.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "getImplicitTags", {
 });
 const _constants = require("../../lib/constants");
 const _handlers = require("../use-cache/handlers");
+const _encodecachetag = require("./encode-cache-tag");
 const _lazyresult = require("./lazy-result");
 const getDerivedTags = (pathname)=>{
     const derivedTags = [
@@ -49,16 +50,18 @@ const getDerivedTags = (pathname)=>{
 }
 async function getImplicitTags(page, pathname, fallbackRouteParams) {
     const tags = new Set();
-    // Add the derived tags from the page.
+    // Add the derived tags from the page. Encode each tag so a non-ASCII
+    // pathname doesn't trip header validation when written to
+    // `x-next-cache-tags`. Idempotent on already-ASCII input.
     const derivedTags = getDerivedTags(page);
     for (let tag of derivedTags){
-        tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`;
+        tag = (0, _encodecachetag.encodeCacheTag)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${tag}`);
         tags.add(tag);
     }
     // Add the tags from the pathname. If the route has unknown params, we don't
     // want to add the pathname as a tag, as it will be invalid.
     if (pathname && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
-        const tag = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`;
+        const tag = (0, _encodecachetag.encodeCacheTag)(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${pathname}`);
         tags.add(tag);
     }
     if (tags.has(`${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}/`)) {

package/.next/standalone/node_modules/next/dist/server/lib/is-rsc-request.js

@@ -0,0 +1,18 @@
+/**
+ * Normalizes the raw RSC header value. Only the literal string "1" is treated
+ * as a valid RSC request marker; malformed or repeated values are ignored.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "isRSCRequestHeader", {
+    enumerable: true,
+    get: function() {
+        return isRSCRequestHeader;
+    }
+});
+function isRSCRequestHeader(value) {
+    return value === '1';
+}
+
+//# sourceMappingURL=is-rsc-request.js.map

package/.next/standalone/node_modules/next/dist/server/lib/mock-request.js

@@ -147,10 +147,11 @@ class MockedResponse extends _stream.default.Writable {
    * A list of buffers that have been written to the response.
    *
    * @internal - used internally by Next.js
-   */ this.buffers = [];
+   */ this.buffers = [], this.totalSize = 0;
         this.statusCode = res.statusCode ?? 200;
         this.socket = res.socket ?? null;
         this.headers = res.headers ? (0, _utils.fromNodeOutgoingHttpHeaders)(res.headers) : new Headers();
+        this.maximumResponseBody = res.maximumResponseBody;
         this.headPromise = new Promise((resolve)=>{
             this.headPromiseResolve = resolve;
         });
@@ -195,10 +196,27 @@ class MockedResponse extends _stream.default.Writable {
         if (this.resWriter) {
             return this.resWriter(chunk);
         }
-        this.buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        if (this.maximumResponseBody !== undefined) {
+            this.totalSize += buffer.byteLength;
+            if (this.totalSize > this.maximumResponseBody) {
+                const error = Object.defineProperty(new Error(`Response body exceeded maximum size of ${this.maximumResponseBody} bytes`), "__NEXT_ERROR_CODE", {
+                    value: "E1143",
+                    enumerable: false,
+                    configurable: true
+                });
+                error.code = 'ERR_MAX_BODY_SIZE_EXCEEDED';
+                this.destroy(error);
+                return true;
+            }
+        }
+        this.buffers.push(buffer);
         return true;
     }
     end() {
+        if (this.destroyed) {
+            return this;
+        }
         this.finished = true;
         return super.end(...arguments);
     }
@@ -216,7 +234,13 @@ class MockedResponse extends _stream.default.Writable {
         // invoked, the 'finish' event will not be emitted.
         //
         // https://nodejs.org/docs/latest-v16.x/api/stream.html#writable_writechunk-encoding-callback
-        callback();
+        //
+        // If the stream was destroyed due to an error, we should propagate it
+        if (this.destroyed && this.errored) {
+            callback(this.errored);
+        } else {
+            callback();
+        }
     }
     writeHead(statusCode, statusMessage, headers) {
         if (!headers && typeof statusMessage !== 'string') {
@@ -397,7 +421,7 @@ class MockedResponse extends _stream.default.Writable {
         });
     }
 }
-function createRequestResponseMocks({ url, headers = {}, method = 'GET', bodyReadable, resWriter, socket = null }) {
+function createRequestResponseMocks({ url, headers = {}, method = 'GET', bodyReadable, resWriter, socket = null, maximumResponseBody }) {
     return {
         req: new MockedRequest({
             url,
@@ -408,7 +432,8 @@ function createRequestResponseMocks({ url, headers = {}, method = 'GET', bodyRea
         }),
         res: new MockedResponse({
             socket,
-            resWriter
+            resWriter,
+            maximumResponseBody
         })
     };
 }

package/.next/standalone/node_modules/next/dist/server/lib/patch-fetch.js

@@ -42,6 +42,7 @@ const _workunitasyncstorageexternal = require("../app-render/work-unit-async-sto
 const _responsecache = require("../response-cache");
 const _cloneresponse = require("./clone-response");
 const _stagedrendering = require("../app-render/staged-rendering");
+const _encodecachetag = require("./encode-cache-tag");
 const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
 const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
 function isFetchPatched() {
@@ -86,7 +87,10 @@ function validateTags(tags, description) {
                 reason: `exceeded max length of ${_constants1.NEXT_CACHE_TAG_MAX_LENGTH}`
             });
         } else {
-            validTags.push(tag);
+            // Encode so a non-ASCII tag can be safely serialized into the
+            // `x-next-cache-tags` HTTP header without tripping Node's header
+            // validation. Length is checked on the raw input above.
+            validTags.push((0, _encodecachetag.encodeCacheTag)(tag));
         }
         if (validTags.length > _constants1.NEXT_CACHE_TAG_MAX_ITEMS) {
             console.warn(`Warning: exceeded max tag count for ${description}, dropped tags:`, tags.slice(i).join(', '));

package/.next/standalone/node_modules/next/dist/server/lib/patch-set-header.js

@@ -9,8 +9,15 @@ Object.defineProperty(exports, "patchSetHeaderWithCookieSupport", {
     }
 });
 const _requestmeta = require("../request-meta");
+const PATCHED_SET_HEADER = Symbol('next.patchSetHeaderWithCookieSupport');
 function patchSetHeaderWithCookieSupport(req, res) {
+    if (res[PATCHED_SET_HEADER]) {
+        return;
+    }
     const setHeader = res.setHeader.bind(res);
+    Object.defineProperty(res, PATCHED_SET_HEADER, {
+        value: true
+    });
     res.setHeader = (name, value)=>{
         // When renders /_error after page is failed, it could attempt to set
         // headers after headers.

package/.next/standalone/node_modules/next/dist/server/lib/router-server.js

@@ -658,7 +658,7 @@ async function initialize(opts) {
                     });
                 }
             });
-            const { matchedOutput, parsedUrl } = await resolveRoutes({
+            const { finished, matchedOutput, parsedUrl, statusCode } = await resolveRoutes({
                 req,
                 res,
                 isUpgradeReq: true,
@@ -669,8 +669,11 @@ async function initialize(opts) {
             if (matchedOutput) {
                 return socket.end();
             }
-            if (parsedUrl.protocol) {
-                return await (0, _proxyrequest.proxyRequest)(req, socket, parsedUrl, head);
+            if (finished && parsedUrl.protocol) {
+                if (!statusCode) {
+                    return await (0, _proxyrequest.proxyRequest)(req, socket, parsedUrl, head);
+                }
+                return socket.end();
             }
         // If there's no matched output, we don't handle the request as user's
         // custom WS server may be listening on the same path.

package/.next/standalone/node_modules/next/dist/server/lib/router-utils/resolve-routes.js

@@ -29,6 +29,7 @@ const _removepathprefix = require("../../../shared/lib/router/utils/remove-path-
 const _nextdata = require("../../normalizers/request/next-data");
 const _basepath = require("../../normalizers/request/base-path");
 const _requestmeta = require("../../request-meta");
+const _isrscrequest = require("../is-rsc-request");
 const _preparedestination = require("../../../shared/lib/router/utils/prepare-destination");
 const _approuterheaders = require("../../../client/components/app-router-headers");
 function _interop_require_default(obj) {
@@ -129,6 +130,10 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
             }
             return pathname;
         };
+        const setIsNextDataRequest = ()=>{
+            (0, _requestmeta.addRequestMeta)(req, 'isNextDataReq', true);
+            req.headers['x-nextjs-data'] = '1';
+        };
         let domainLocale;
         let defaultLocale;
         let initialLocaleResult = undefined;
@@ -199,7 +204,7 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                         continue;
                     }
                     if (pageOutput && (curPathname == null ? void 0 : curPathname.startsWith('/_next/data'))) {
-                        (0, _requestmeta.addRequestMeta)(req, 'isNextDataReq', true);
+                        setIsNextDataRequest();
                     }
                     if (config.useFileSystemPublicRoutes || didRewrite) {
                         return pageOutput;
@@ -258,16 +263,25 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                         if (hadBasePath && normalizers.basePath) {
                             normalized = normalizers.basePath.normalize(normalized, true);
                         }
+                        const isNextDataPath = (0, _pathhasprefix.pathHasPrefix)(normalized, '/_next/data') && normalized.endsWith('.json');
+                        const hasCurrentBuildIdDataPath = normalizers.data.match(normalized);
                         let updated = false;
-                        if (normalizers.data.match(normalized)) {
+                        if (hasCurrentBuildIdDataPath) {
                             updated = true;
-                            (0, _requestmeta.addRequestMeta)(req, 'isNextDataReq', true);
                             normalized = normalizers.data.normalize(normalized, true);
                         }
+                        if (isNextDataPath) {
+                            setIsNextDataRequest();
+                        }
                         if (config.i18n) {
                             const curLocaleResult = (0, _normalizelocalepath.normalizeLocalePath)(normalized, config.i18n.locales);
                             if (curLocaleResult.detectedLocale) {
                                 (0, _requestmeta.addRequestMeta)(req, 'locale', curLocaleResult.detectedLocale);
+                            } else if (defaultLocale && !curLocaleResult.pathname.startsWith('/_next/')) {
+                                // Match normalized _next/data requests against the same
+                                // locale-prefixed internal pathname shape used by direct page
+                                // requests when the default locale was inferred.
+                                normalized = (0, _addpathprefix.addPathPrefix)(curLocaleResult.pathname === '/' ? `/${defaultLocale}` : (0, _addpathprefix.addPathPrefix)(curLocaleResult.pathname || '', `/${defaultLocale}`));
                             }
                         }
                         // If we updated the pathname, and it had a base path, re-add the
@@ -562,7 +576,7 @@ function getResolveRoutes(fsChecker, config, opts, renderServer, renderServerOpt
                     const parsedDestinationOrigin = parsedDestination.origin;
                     const isAllowedOrigin = parsedDestinationOrigin ? (_config_experimental_clientParamParsingOrigins = config.experimental.clientParamParsingOrigins) == null ? void 0 : _config_experimental_clientParamParsingOrigins.some((origin)=>new RegExp(origin).test(parsedDestinationOrigin)) : false;
                     // Set the rewrite headers only if this is a RSC request.
-                    if (req.headers[_approuterheaders.RSC_HEADER] === '1' && (!parsedDestination.origin || isAllowedOrigin)) {
+                    if ((0, _isrscrequest.isRSCRequestHeader)(req.headers[_approuterheaders.RSC_HEADER]) && (!parsedDestination.origin || isAllowedOrigin)) {
                         // We set the rewritten path and query headers on the response now
                         // that we know that the it's not an external rewrite.
                         if (parsedUrl.pathname !== parsedDestination.pathname) {

package/.next/standalone/node_modules/next/dist/server/lib/server-ipc/utils.js

@@ -68,7 +68,9 @@ const INTERNAL_HEADERS = [
     'x-middleware-next',
     'x-now-route-matches',
     'x-matched-path',
-    'x-next-resume-state-length'
+    'x-nextjs-data',
+    'x-next-resume-state-length',
+    'next-resume'
 ];
 const filterInternalHeaders = (headers)=>{
     for(const header in headers){

package/.next/standalone/node_modules/next/dist/server/lib/start-server.js

@@ -178,7 +178,7 @@ async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server
 async function startServer(serverOptions) {
     const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate, serverFastRefresh } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"16.2.4"})`;
+    process.title = `next-server (v${"16.2.9"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{

package/.next/standalone/node_modules/next/dist/server/next-server.js

@@ -774,7 +774,7 @@ class NextNodeServer extends _baseserver.default {
                     href += `${href.includes('?') ? '&' : '?'}dpl=${dpl}`;
                 }
             }
-            const imageUpstream = paramsResult.isAbsolute ? await fetchExternalImage(href, this.nextConfig.images.dangerouslyAllowLocalIP, this.nextConfig.images.maximumResponseBody, this.nextConfig.images.maximumRedirects) : await fetchInternalImage(href, req.originalRequest, res.originalResponse, handleInternalReq);
+            const imageUpstream = paramsResult.isAbsolute ? await fetchExternalImage(href, this.nextConfig.images.dangerouslyAllowLocalIP, this.nextConfig.images.maximumResponseBody, this.nextConfig.images.maximumRedirects) : await fetchInternalImage(href, req.originalRequest, res.originalResponse, this.nextConfig.images.maximumResponseBody, handleInternalReq);
             return imageOptimizer(imageUpstream, paramsResult, this.nextConfig, {
                 isDev: this.dev,
                 previousCacheEntry

package/.next/standalone/node_modules/next/dist/server/request/fallback-params.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    buildDynamicSegmentPlaceholder: null,
     createOpaqueFallbackRouteParams: null,
-    getFallbackRouteParams: null
+    getFallbackRouteParams: null,
+    getPlaceholderFallbackRouteParams: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -13,17 +15,24 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    buildDynamicSegmentPlaceholder: function() {
+        return buildDynamicSegmentPlaceholder;
+    },
     createOpaqueFallbackRouteParams: function() {
         return createOpaqueFallbackRouteParams;
     },
     getFallbackRouteParams: function() {
         return getFallbackRouteParams;
+    },
+    getPlaceholderFallbackRouteParams: function() {
+        return getPlaceholderFallbackRouteParams;
     }
 });
 const _utils = require("../../build/static-paths/utils");
 const _getshortdynamicparamtype = require("../app-render/get-short-dynamic-param-type");
 const _app = require("../../shared/lib/router/routes/app");
 const _extractpathnamerouteparamsegmentsfromloadertree = require("../../build/static-paths/app/extract-pathname-route-param-segments-from-loader-tree");
+const _getsegmentparam = require("../../shared/lib/router/utils/get-segment-param");
 function createOpaqueFallbackRouteParams(fallbackRouteParams) {
     // If there are no fallback route params, we can return early.
     if (fallbackRouteParams.length === 0) return null;
@@ -42,6 +51,23 @@ function createOpaqueFallbackRouteParams(fallbackRouteParams) {
     }
     return keys;
 }
+function buildDynamicSegmentPlaceholder(param) {
+    const { repeat, optional } = (0, _getsegmentparam.getParamProperties)(param.paramType);
+    if (optional) {
+        return `[[...${param.paramName}]]`;
+    }
+    if (repeat) {
+        return `[...${param.paramName}]`;
+    }
+    return `[${param.paramName}]`;
+}
+function getPlaceholderFallbackRouteParams(params, fallbackRouteParams) {
+    return fallbackRouteParams.filter((param)=>{
+        const placeholder = buildDynamicSegmentPlaceholder(param);
+        const value = params == null ? void 0 : params[param.paramName];
+        return value === placeholder || Array.isArray(value) && value.length === 1 && value[0] === placeholder;
+    });
+}
 function getFallbackRouteParams(page, routeModule) {
     const route = (0, _app.parseAppRoute)(page, true);
     // Extract the pathname-contributing segments from the loader tree. This

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

@@ -522,6 +522,7 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
             page: this.definition.page,
             renderOpts: context.renderOpts,
             buildId: context.sharedContext.buildId,
+            deploymentId: context.sharedContext.deploymentId,
             previouslyRevalidatedTags: []
         };
         // Add the fetchCache option to the renderOpts.

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

@@ -21,6 +21,7 @@ const _apiutils = require("../api-utils");
 const _normalizedatapath = require("../../shared/lib/page-path/normalize-data-path");
 const _pathhasprefix = require("../../shared/lib/router/utils/path-has-prefix");
 const _requestmeta = require("../request-meta");
+const _patchsetheader = require("../lib/patch-set-header");
 const _normalizepagepath = require("../../shared/lib/page-path/normalize-page-path");
 const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
 const _incrementalcache = require("../lib/incremental-cache");
@@ -340,6 +341,9 @@ class RouteModule {
         let absoluteProjectDir;
         // edge runtime handles loading instrumentation at the edge adapter level
         if (process.env.NEXT_RUNTIME !== 'edge') {
+            if (res) {
+                (0, _patchsetheader.patchSetHeaderWithCookieSupport)(req, res);
+            }
             const { join, relative } = require('node:path');
             absoluteProjectDir = join(/* turbopackIgnore: true */ process.cwd(), (0, _requestmeta.getRequestMeta)(req, 'relativeProjectDir') || this.relativeProjectDir);
             const absoluteDistDir = (0, _requestmeta.getRequestMeta)(req, 'distDir');
@@ -478,7 +482,13 @@ class RouteModule {
             }
         }
         serverUtils.normalizeCdnUrl(req, combinedParamKeys);
-        serverUtils.normalizeQueryParams(query, routeParamKeys);
+        // When Next is not hosted in a single process, upstream proxies will add query values for route params that were used to match the route.
+        // Outside of that environment, there is no reason to do any normalization to honor those query values.
+        if (!(routerServerContext == null ? void 0 : routerServerContext.isWrappedByNextServer)) {
+            serverUtils.normalizeQueryParams(query, routeParamKeys);
+        } else {
+            serverUtils.filterInternalQuery(query, []);
+        }
         serverUtils.filterInternalQuery(originalQuery, combinedParamKeys);
         if (pageIsDynamic) {
             const queryResult = serverUtils.normalizeDynamicRouteParams(query, true);

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

@@ -92,6 +92,23 @@ function interpolateDynamicPath(pathname, params, defaultRouteRegex) {
     return pathname;
 }
 function normalizeDynamicRouteParams(query, defaultRouteRegex, defaultRouteMatches, ignoreMissingOptional) {
+    const isDefaultValueMatch = (candidateValue, defaultValue)=>{
+        if (!candidateValue) {
+            return false;
+        }
+        let normalizedCandidateValue = (0, _apppaths.normalizeRscURL)(candidateValue);
+        for(let i = 0; i < 3; i++){
+            if (normalizedCandidateValue === defaultValue) {
+                return true;
+            }
+            const decodedCandidateValue = (0, _decodequerypathparameter.decodeQueryPathParameter)(normalizedCandidateValue);
+            if (decodedCandidateValue === normalizedCandidateValue) {
+                break;
+            }
+            normalizedCandidateValue = decodedCandidateValue;
+        }
+        return false;
+    };
     let hasValidParams = true;
     let params = {};
     for (const key of Object.keys(defaultRouteRegex.groups)){
@@ -107,8 +124,8 @@ function normalizeDynamicRouteParams(query, defaultRouteRegex, defaultRouteMatch
         const defaultValue = defaultRouteMatches[key];
         const isOptional = defaultRouteRegex.groups[key].optional;
         const isDefaultValue = Array.isArray(defaultValue) ? defaultValue.some((defaultVal)=>{
-            return Array.isArray(value) ? value.some((val)=>val.includes(defaultVal)) : value == null ? void 0 : value.includes(defaultVal);
-        }) : value == null ? void 0 : value.includes(defaultValue);
+            return Array.isArray(value) ? value.some((val)=>isDefaultValueMatch(val, defaultVal)) : isDefaultValueMatch(value, defaultVal);
+        }) : Array.isArray(value) ? value.some((val)=>isDefaultValueMatch(val, defaultValue)) : isDefaultValueMatch(value, defaultValue);
         if (isDefaultValue || typeof value === 'undefined' && !(isOptional && ignoreMissingOptional)) {
             return {
                 params: {},

package/.next/standalone/node_modules/next/dist/server/stream-utils/node-web-streams-helper.js

@@ -402,9 +402,9 @@ function createHeadInsertionTransformStream(insert) {
         }
     });
 }
-function createClientResumeScriptInsertionTransformStream() {
+async function createClientResumeScriptInsertionTransformStream() {
     const segmentPath = '/_full';
-    const cacheBustingHeader = (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', '/_full', undefined, undefined //       headers[NEXT_URL]
+    const cacheBustingHeader = await (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', '/_full', undefined, undefined //       headers[NEXT_URL]
     );
     const searchStr = `${_approuterheaders.NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`;
     const NEXT_CLIENT_RESUME_SCRIPT = `<script>__NEXT_CLIENT_RESUME=fetch(location.pathname+'?${searchStr}',{credentials:'same-origin',headers:{'${_approuterheaders.RSC_HEADER}': '1','${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}': '1','${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}': '${segmentPath}'}})</script>`;
@@ -442,7 +442,7 @@ function createClientResumeScriptInsertionTransformStream() {
         }
     });
 }
-function createInstantTestScriptInsertionTransformStream(requestId) {
+async function createInstantTestScriptInsertionTransformStream(requestId) {
     // Kick off a fetch for the static RSC payload. This is the hydration
     // source for the locked static shell — same as the __NEXT_CLIENT_RESUME
     // fetch used for fallback routes, but with NEXT_INSTANT_PREFETCH_HEADER
@@ -452,7 +452,7 @@ function createInstantTestScriptInsertionTransformStream(requestId) {
     // as the feature flag (truthy = instant test mode). The client processes
     // this as a fallback prerender payload for hydration.
     const segmentPath = '/_full';
-    const cacheBustingHeader = (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', segmentPath, undefined, undefined);
+    const cacheBustingHeader = await (0, _cachebustingsearchparam.computeCacheBustingSearchParam)('1', segmentPath, undefined, undefined);
     const searchStr = `${_approuterheaders.NEXT_RSC_UNION_QUERY}=${cacheBustingHeader}`;
     // In dev mode, inject self.__next_r (request ID) so that HMR WebSocket
     // and debug channel initialization don't crash. The static shell
@@ -804,7 +804,7 @@ async function continueStaticFallbackPrerender(prerenderStream, { inlinedDataStr
         // Insert generated tags to head
         createHeadInsertionTransformStream(getServerInsertedHTML),
         // Insert the client resume script into the head
-        createClientResumeScriptInsertionTransformStream(),
+        await createClientResumeScriptInsertionTransformStream(),
         // Transform metadata
         createMetadataTransformStream(getServerInsertedMetadata),
         // Insert the inlined data (Flight data, form state, etc.) stream into the HTML

package/.next/standalone/node_modules/next/dist/server/use-cache/use-cache-wrapper.js

@@ -842,7 +842,7 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     // safely reuse the results across builds yet. In the meantime we add the buildId to the
     // arguments as a seed to ensure they're not reused. Remove this once Action IDs hash
     // the implementation.
-    const buildId = workStore.buildId;
+    const buildId = workStore.deploymentId || workStore.buildId;
     // In dev mode, when the HMR refresh hash is set, we include it in the
     // cache key. This ensures that cache entries are not reused when server
     // components have been edited. This is a very coarse approach. But it's

package/.next/standalone/node_modules/next/dist/server/web/adapter.js

@@ -41,6 +41,7 @@ const _webonclose = require("./web-on-close");
 const _getedgepreviewprops = require("./get-edge-preview-props");
 const _builtinrequestcontext = require("../after/builtin-request-context");
 const _implicittags = require("../lib/implicit-tags");
+const _isrscrequest = require("../lib/is-rsc-request");
 const _requestmeta = require("../request-meta");
 class NextRequestHint extends _request.NextRequest {
     constructor(params){
@@ -128,9 +129,10 @@ async function adapter(params) {
         buildId = requestURL.buildId || '';
         requestURL.buildId = '';
     }
+    let deploymentId = process.env.NEXT_DEPLOYMENT_ID;
     const requestHeaders = (0, _utils.fromNodeOutgoingHttpHeaders)(params.request.headers);
     const isNextDataRequest = requestHeaders.has('x-nextjs-data');
-    const isRSCRequest = requestHeaders.get(_approuterheaders.RSC_HEADER) === '1';
+    const isRSCRequest = (0, _isrscrequest.isRSCRequestHeader)(requestHeaders.get(_approuterheaders.RSC_HEADER));
     if (isNextDataRequest && requestURL.pathname === '/index') {
         requestURL.pathname = '/';
     }
@@ -249,6 +251,7 @@ async function adapter(params) {
                         },
                         isPrefetchRequest: request.headers.get(_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER) === '1',
                         buildId: buildId ?? '',
+                        deploymentId: deploymentId ?? '',
                         previouslyRevalidatedTags: []
                     });
                     return await _workasyncstorageexternal.workAsyncStorage.run(workStore, ()=>_workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, params.handler, request, event));

package/.next/standalone/node_modules/next/dist/server/web/edge-route-module-wrapper.js

@@ -90,7 +90,8 @@ class EdgeRouteModuleWrapper {
                 cacheLifeProfiles: nextConfig.cacheLife
             },
             sharedContext: {
-                buildId: ''
+                buildId: '',
+                deploymentId: ''
             }
         };
         // Get the response from the handler.