failproofai 0.0.10 → 0.0.11-beta.1

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-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.6"})`;
     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.

package/.next/standalone/node_modules/next/dist/shared/lib/errors/canary-only-config-error.js

@@ -21,7 +21,7 @@ _export(exports, {
     }
 });
 function isStableBuild() {
-    return !"16.2.4"?.includes('canary') && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
+    return !"16.2.6"?.includes('canary') && !process.env.__NEXT_TEST_MODE && !process.env.NEXT_PRIVATE_LOCAL_DEV;
 }
 class CanaryOnlyConfigError extends Error {
     constructor(arg){

package/.next/standalone/node_modules/next/dist/{server → shared/lib}/htmlescape.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     ESCAPE_REGEX: null,
+    htmlEscapeAttributeString: null,
     htmlEscapeJsonString: null
 });
 function _export(target, all) {
@@ -18,6 +19,9 @@ _export(exports, {
     ESCAPE_REGEX: function() {
         return ESCAPE_REGEX;
     },
+    htmlEscapeAttributeString: function() {
+        return htmlEscapeAttributeString;
+    },
     htmlEscapeJsonString: function() {
         return htmlEscapeJsonString;
     }
@@ -30,8 +34,19 @@ const ESCAPE_LOOKUP = {
     '\u2029': '\\u2029'
 };
 const ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+const ATTRIBUTE_ESCAPE_LOOKUP = {
+    '&': '&amp;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '<': '&lt;',
+    '>': '&gt;'
+};
+const ATTRIBUTE_ESCAPE_REGEX = /[&"'<>]/g;
 function htmlEscapeJsonString(str) {
     return str.replace(ESCAPE_REGEX, (match)=>ESCAPE_LOOKUP[match]);
 }
+function htmlEscapeAttributeString(str) {
+    return str.replace(ATTRIBUTE_ESCAPE_REGEX, (match)=>ATTRIBUTE_ESCAPE_LOOKUP[match]);
+}
 
 //# sourceMappingURL=htmlescape.js.map

package/.next/standalone/node_modules/next/dist/shared/lib/router/routes/app.js

@@ -31,6 +31,17 @@ _export(exports, {
 const _invarianterror = require("../../invariant-error");
 const _getsegmentparam = require("../utils/get-segment-param");
 const _interceptionroutes = require("../utils/interception-routes");
+function normalizeEncodedDynamicPlaceholder(segment) {
+    if (!/%5b|%5d/i.test(segment)) {
+        return segment;
+    }
+    try {
+        const decodedSegment = decodeURIComponent(segment);
+        return (0, _getsegmentparam.getSegmentParam)(decodedSegment) ? decodedSegment : segment;
+    } catch  {
+        return segment;
+    }
+}
 function parseAppRouteSegment(segment) {
     if (segment === '') {
         return null;
@@ -80,8 +91,9 @@ function parseAppRoute(pathname, normalized) {
     let interceptingRoute;
     let interceptedRoute;
     for (const segment of pathnameSegments){
+        const normalizedSegment = normalizeEncodedDynamicPlaceholder(segment);
         // Parse the segment into an AppSegment.
-        const appSegment = parseAppRouteSegment(segment);
+        const appSegment = parseAppRouteSegment(normalizedSegment);
         if (!appSegment) {
             continue;
         }

package/.next/standalone/node_modules/next/dist/shared/lib/router/utils/cache-busting-search-param.js

@@ -2,23 +2,69 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "computeCacheBustingSearchParam", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    computeCacheBustingSearchParam: null,
+    computeLegacyCacheBustingSearchParam: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    computeCacheBustingSearchParam: function() {
         return computeCacheBustingSearchParam;
+    },
+    computeLegacyCacheBustingSearchParam: function() {
+        return computeLegacyCacheBustingSearchParam;
     }
 });
 const _hash = require("../../hash");
-function computeCacheBustingSearchParam(prefetchHeader, segmentPrefetchHeader, stateTreeHeader, nextUrlHeader) {
+const CACHE_BUSTING_SEARCH_PARAM_DIGEST_BYTES = 12;
+const textEncoder = new TextEncoder();
+function encodeCacheBustingSearchParam(bytes) {
+    let binary = '';
+    for(let i = 0; i < bytes.length; i++){
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function normalizeCacheBustingInput(value) {
+    if (value === undefined) {
+        return '0';
+    }
+    return Array.isArray(value) ? value.join(',') : value;
+}
+function createCacheBustingSearchParamInput(prefetchHeader, segmentPrefetchHeader, stateTreeHeader, nextUrlHeader) {
     if ((prefetchHeader === undefined || prefetchHeader === '0') && segmentPrefetchHeader === undefined && stateTreeHeader === undefined && nextUrlHeader === undefined) {
+        return null;
+    }
+    return [
+        prefetchHeader ?? '0',
+        normalizeCacheBustingInput(segmentPrefetchHeader),
+        normalizeCacheBustingInput(stateTreeHeader),
+        normalizeCacheBustingInput(nextUrlHeader)
+    ].join(',');
+}
+async function computeCacheBustingSearchParamFromInput(input) {
+    // Truncate SHA-256 to 96 bits to keep `_rsc` compact
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', textEncoder.encode(input));
+    return encodeCacheBustingSearchParam(new Uint8Array(digest).subarray(0, CACHE_BUSTING_SEARCH_PARAM_DIGEST_BYTES));
+}
+async function computeCacheBustingSearchParam(prefetchHeader, segmentPrefetchHeader, stateTreeHeader, nextUrlHeader) {
+    const input = createCacheBustingSearchParamInput(prefetchHeader, segmentPrefetchHeader, stateTreeHeader, nextUrlHeader);
+    if (input === null) {
+        return '';
+    }
+    return computeCacheBustingSearchParamFromInput(input);
+}
+function computeLegacyCacheBustingSearchParam(prefetchHeader, segmentPrefetchHeader, stateTreeHeader, nextUrlHeader) {
+    const input = createCacheBustingSearchParamInput(prefetchHeader, segmentPrefetchHeader, stateTreeHeader, nextUrlHeader);
+    if (input === null) {
         return '';
     }
-    return (0, _hash.hexHash)([
-        prefetchHeader || '0',
-        segmentPrefetchHeader || '0',
-        stateTreeHeader || '0',
-        nextUrlHeader || '0'
-    ].join(','));
+    return (0, _hash.hexHash)(input);
 }
 
 //# sourceMappingURL=cache-busting-search-param.js.map

package/.next/standalone/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -81,7 +81,7 @@ function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "16.2.4"
+        nextVersion: "16.2.6"
     };
     return traits;
 }

package/.next/standalone/node_modules/next/dist/telemetry/events/swc-load-failure.js

@@ -38,7 +38,7 @@ async function eventSwcLoadFailure(event) {
     telemetry.record({
         eventName: EVENT_PLUGIN_PRESENT,
         payload: {
-            nextVersion: "16.2.4",
+            nextVersion: "16.2.6",
             glibcVersion,
             installedSwcPackages,
             arch: process.arch,

package/.next/standalone/node_modules/next/dist/telemetry/events/version.js

@@ -12,12 +12,12 @@ const EVENT_VERSION = 'NEXT_CLI_SESSION_STARTED';
 function eventCliSession(nextConfig, event) {
     var _nextConfig_experimental_staleTimes, _nextConfig_experimental_staleTimes1, _nextConfig_reactCompiler, _nextConfig_reactCompiler1;
     // This should be an invariant, if it fails our build tooling is broken.
-    if (typeof "16.2.4" !== 'string') {
+    if (typeof "16.2.6" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.2.4",
+        nextVersion: "16.2.6",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,