@vectorize-io/hindsight-control-plane 0.6.0 → 0.6.2

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

@@ -204,29 +204,35 @@ function serializeError(dev, err) {
         statusCode: 500
     };
 }
+function getSafariCacheBusterQueryString(req) {
+    if (process.env.__NEXT_DEV_SERVER) {
+        const userAgent = (req.headers['user-agent'] || '').toLowerCase();
+        if (userAgent.includes('safari') && !userAgent.includes('chrome')) {
+            return `?ts=${Date.now()}`;
+        }
+    }
+    return '';
+}
 async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sharedContext, renderContext) {
     // Adds support for reading `cookies` in `getServerSideProps` when SSR.
     (0, _apiutils.setLazyProp)({
         req: req
     }, 'cookies', (0, _getcookieparser.getCookieParser)(req.headers));
-    let baseAssetQueryString = process.env.__NEXT_DEV_SERVER && renderOpts.assetQueryString || '';
-    if (process.env.__NEXT_DEV_SERVER && !baseAssetQueryString) {
-        const userAgent = (req.headers['user-agent'] || '').toLowerCase();
-        if (userAgent.includes('safari') && !userAgent.includes('chrome')) {
-            // In dev we invalidate the cache by appending a timestamp to the resource URL.
-            // This is a workaround to fix https://github.com/vercel/next.js/issues/5860
-            // TODO: remove this workaround when https://bugs.webkit.org/show_bug.cgi?id=187726 is fixed.
-            // Note: The workaround breaks breakpoints on reload since the script url always changes,
-            // so we only apply it to Safari.
-            baseAssetQueryString = `?ts=${Date.now()}`;
-        }
-    }
-    const mutableAssetQueryString = baseAssetQueryString + (sharedContext.deploymentId ? `${baseAssetQueryString ? '&' : '?'}dpl=${sharedContext.deploymentId}` : '');
-    const assetQueryString = baseAssetQueryString + (sharedContext.clientAssetToken ? `${baseAssetQueryString ? '&' : '?'}dpl=${sharedContext.clientAssetToken}` : '');
-    const metadata = {
-        assetQueryString,
-        mutableAssetQueryString
-    };
+    // cssCacheBuster is a workaround for a Safari bug
+    // (https://bugs.webkit.org/show_bug.cgi?id=187726) where preloaded CSS
+    // resources are cached and not re-fetched on HMR. It must only be applied
+    // to CSS and font assets — not to script tags — because the Turbopack
+    // runtime infers ASSET_SUFFIX from the executing script's query string and
+    // leaks it onto all static asset URLs (including images), causing
+    // next/image validation errors.
+    // See https://github.com/vercel/next.js/issues/92118.
+    const cssCacheBuster = getSafariCacheBusterQueryString(req);
+    const mutableAssetQueryString = sharedContext.deploymentId ? `?dpl=${sharedContext.deploymentId}` : '';
+    const assetQueryString = sharedContext.clientAssetToken ? `?dpl=${sharedContext.clientAssetToken}` : '';
+    // cssAssetQueryString is assetQueryString with the cacheBuster prepended.
+    // Use this for CSS and font URLs; use assetQueryString for script URLs.
+    const cssAssetQueryString = cssCacheBuster + (sharedContext.clientAssetToken ? `${cssCacheBuster ? '&' : '?'}dpl=${sharedContext.clientAssetToken}` : '');
+    const metadata = {};
     // don't modify original query object
     query = Object.assign({}, query);
     const { err, pageConfig = {}, buildManifest, reactLoadableManifest, ErrorDebug, getStaticProps, getStaticPaths, getServerSideProps, isNextDataRequest, params, previewProps, basePath, images, runtime: globalRuntime, isExperimentalCompile, expireTime } = renderOpts;
@@ -968,26 +974,21 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
         // If it has getInitialProps, we will render the shell in `renderPage`.
         // Otherwise we do it right now.
         let documentInitialPropsRes;
-        const [rawStyledJsxInsertedHTML, content] = await Promise.all([
-            renderToString(styledJsxInsertedHTML()),
-            (async ()=>{
-                if (hasDocumentGetInitialProps) {
-                    documentInitialPropsRes = await loadDocumentInitialProps(renderShell);
-                    if (documentInitialPropsRes === null) return null;
-                    const { docProps } = documentInitialPropsRes;
-                    return docProps.html;
-                } else {
-                    documentInitialPropsRes = {};
-                    const stream = await renderShell(App, Component);
-                    await stream.allReady;
-                    return (0, _nodewebstreamshelper.streamToString)(stream);
-                }
-            })()
-        ]);
-        if (content === null) {
-            return null;
+        let content;
+        if (hasDocumentGetInitialProps) {
+            documentInitialPropsRes = await loadDocumentInitialProps(renderShell);
+            if (documentInitialPropsRes === null) {
+                content = null;
+            } else {
+                const { docProps } = documentInitialPropsRes;
+                content = docProps.html;
+            }
+        } else {
+            documentInitialPropsRes = {};
+            const stream = await renderShell(App, Component);
+            await stream.allReady;
+            content = await (0, _nodewebstreamshelper.streamToString)(stream);
         }
-        const contentHTML = rawStyledJsxInsertedHTML + content;
         // @ts-ignore: documentInitialPropsRes is set
         const { docProps } = documentInitialPropsRes || {};
         const documentElement = (htmlProps)=>{
@@ -1008,6 +1009,12 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
             styles = jsxStyleRegistry.styles();
             jsxStyleRegistry.flush();
         }
+        // Registry is now flushed; rawStyledJsxInsertedHTML will be empty.
+        const rawStyledJsxInsertedHTML = await renderToString(styledJsxInsertedHTML());
+        if (content === null) {
+            return null;
+        }
+        const contentHTML = rawStyledJsxInsertedHTML + content;
         return {
             contentHTML,
             documentElement,
@@ -1079,8 +1086,9 @@ async function renderToHTMLImpl(req, res, pathname, query, renderOpts, extra, sh
         // Only enabled in production as development mode has features relying on HMR (style injection for example)
         unstable_runtimeJS: process.env.NODE_ENV === 'production' ? pageConfig.unstable_runtimeJS : undefined,
         unstable_JsPreload: pageConfig.unstable_JsPreload,
-        assetQueryString: assetQueryString || '',
-        mutableAssetQueryString: mutableAssetQueryString || '',
+        assetQueryString,
+        cssAssetQueryString,
+        mutableAssetQueryString,
         scriptLoader,
         locale,
         disableOptimizedLoading,

package/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/standalone/node_modules/next/dist/server/route-modules/app-route/module.js

@@ -115,9 +115,9 @@ class WrappedNextRouterError {
 }
 class AppRouteRouteModule extends _routemodule.RouteModule {
     static #_ = this.sharedModules = _sharedmodules;
-    constructor({ userland, definition, distDir, relativeProjectDir, resolvedPagePath, nextConfigOutput }){
+    constructor({ userland, getUserland, definition, distDir, relativeProjectDir, resolvedPagePath, nextConfigOutput }){
         super({
-            userland,
+            userland: userland,
             definition,
             distDir,
             relativeProjectDir
@@ -134,13 +134,14 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
    */ this.actionAsyncStorage = _actionasyncstorageexternal.actionAsyncStorage;
         this.resolvedPagePath = resolvedPagePath;
         this.nextConfigOutput = nextConfigOutput;
+        this._getUserland = getUserland;
         // Automatically implement some methods if they aren't implemented by the
         // userland module.
         this.methods = (0, _autoimplementmethods.autoImplementMethods)(userland);
         // Get the non-static methods for this route.
         this.hasNonStaticMethods = hasNonStaticMethods(userland);
         // Get the dynamic property from the userland module.
-        this.dynamic = this.userland.dynamic;
+        this.dynamic = userland.dynamic;
         if (this.nextConfigOutput === 'export') {
             if (this.dynamic === 'force-dynamic') {
                 throw Object.defineProperty(new Error(`export const dynamic = "force-dynamic" on page "${definition.pathname}" cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export`), "__NEXT_ERROR_CODE", {
@@ -191,8 +192,19 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         if (!(0, _http.isHTTPMethod)(method)) return ()=>new Response(null, {
                 status: 400
             });
-        // Return the handler.
-        return this.methods[method];
+        return (0, _autoimplementmethods.autoImplementMethods)(this.userland)[method];
+    }
+    /**
+   * Like resolve(), but re-fetches the userland module on every call via the
+   * async getter. Only used in Turbopack dev mode, where server HMR disposes
+   * modules between requests. The async wrapper also unwraps async-module
+   * Promises produced by ESM-only serverExternalPackages.
+   */ async resolveWithGetter(method, getUserland) {
+        if (!(0, _http.isHTTPMethod)(method)) return ()=>new Response(null, {
+                status: 400
+            });
+        const userland = await getUserland();
+        return (0, _autoimplementmethods.autoImplementMethods)(userland)[method];
     }
     async do(handler, actionStore, workStore, // @TODO refactor to not take this argument but instead construct the RequestStore
     // inside this function. Right now we get passed a RequestStore even when
@@ -501,13 +513,16 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         return res;
     }
     async handle(req, context) {
-        // Get the handler function for the given method.
-        const handler = this.resolve(req.method);
+        // Get the handler function for the given method. In Turbopack dev mode,
+        // use resolveWithGetter() to re-fetch the live userland on every request
+        // In all other modes, resolve() is synchronous.
+        const handler = this._getUserland ? await this.resolveWithGetter(req.method, this._getUserland) : this.resolve(req.method);
         // Get the context for the static generation.
         const staticGenerationContext = {
             page: this.definition.page,
             renderOpts: context.renderOpts,
             buildId: context.sharedContext.buildId,
+            deploymentId: context.sharedContext.deploymentId,
             previouslyRevalidatedTags: []
         };
         // Add the fetchCache option to the renderOpts.
@@ -526,7 +541,7 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
         const response = await this.actionAsyncStorage.run(actionStore, ()=>this.workUnitAsyncStorage.run(requestStore, ()=>this.workAsyncStorage.run(workStore, async ()=>{
                     // Check to see if we should bail out of static generation based on
                     // having non-static methods.
-                    if (this.hasNonStaticMethods) {
+                    if (hasNonStaticMethods(this.userland)) {
                         if (workStore.isStaticGeneration) {
                             const err = Object.defineProperty(new _hooksservercontext.DynamicServerError('Route is configured with methods that cannot be statically generated.'), "__NEXT_ERROR_CODE", {
                                 value: "E582",
@@ -542,7 +557,8 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
                     // proxying it in certain circumstances based on execution type and configuration
                     let request = req;
                     // Update the static generation store based on the dynamic property.
-                    switch(this.dynamic){
+                    const { dynamic } = this.userland;
+                    switch(dynamic){
                         case 'force-dynamic':
                             {
                                 // Routes of generated paths should be dynamic
@@ -580,7 +596,7 @@ class AppRouteRouteModule extends _routemodule.RouteModule {
                             request = proxyNextRequest(req, workStore);
                             break;
                         default:
-                            this.dynamic;
+                            dynamic;
                     }
                     const tracer = (0, _tracer.getTracer)();
                     // Update the root span attribute for the route.

package/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/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/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/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/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/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/standalone/node_modules/next/dist/shared/lib/errors/canary-only-config-error.js

@@ -21,7 +21,7 @@ _export(exports, {
     }
 });
 function isStableBuild() {
-    return !"16.2.0"?.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/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/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/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/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.0"
+        nextVersion: "16.2.6"
     };
     return traits;
 }

package/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.0",
+            nextVersion: "16.2.6",
             glibcVersion,
             installedSwcPackages,
             arch: process.arch,

package/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.0" !== 'string') {
+    if (typeof "16.2.6" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.2.0",
+        nextVersion: "16.2.6",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,