@vectorize-io/hindsight-control-plane 0.6.1 → 0.7.0

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

@@ -25,6 +25,7 @@ const _utils = require("../shared/lib/utils");
 const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
 const _url = require("url");
 const _formathostname = require("./lib/format-hostname");
+const _isrscrequest = require("./lib/is-rsc-request");
 const _constants = require("../shared/lib/constants");
 const _utils1 = require("../shared/lib/router/utils");
 const _utils2 = require("./utils");
@@ -76,11 +77,11 @@ const _streamingmetadata = require("./lib/streaming-metadata");
 const _decodequerypathparameter = require("./lib/decode-query-path-parameter");
 const _nofallbackerrorexternal = require("../shared/lib/no-fallback-error.external");
 const _fixmojibake = require("./lib/fix-mojibake");
-const _cachebustingsearchparam = require("../shared/lib/router/utils/cache-busting-search-param");
 const _setcachebustingsearchparam = require("../client/components/router-reducer/set-cache-busting-search-param");
 const _fallbackparams = require("./request/fallback-params");
 const _routekind = require("./route-kind");
 const _postponedrequestbody = require("./lib/postponed-request-body");
+const _cachebustingsearchparam = require("../shared/lib/router/utils/cache-busting-search-param");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -171,7 +172,7 @@ class Server {
                 // request path for flight information.
                 (0, _stripflightheaders.stripFlightHeaders)(req.headers);
                 return false;
-            } else if (req.headers[_approuterheaders.RSC_HEADER] === '1') {
+            } else if ((0, _isrscrequest.isRSCRequestHeader)(req.headers[_approuterheaders.RSC_HEADER])) {
                 (0, _requestmeta.addRequestMeta)(req, 'isRSCRequest', true);
                 if (req.headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] === '1') {
                     (0, _requestmeta.addRequestMeta)(req, 'isPrefetchRSCRequest', true);
@@ -1208,12 +1209,19 @@ class Server {
             // This should only happen for static prefetches, so we only handle those here.
             (0, _requestmeta.getRequestMeta)(req, 'isPrefetchRSCRequest') ? '1' : undefined;
             const segmentPrefetchRSCRequest = headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER] || (0, _requestmeta.getRequestMeta)(req, 'segmentPrefetchRSCRequest');
-            const expectedHash = (0, _cachebustingsearchparam.computeCacheBustingSearchParam)(routerPrefetch, segmentPrefetchRSCRequest, headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER], headers[_approuterheaders.NEXT_URL]);
+            const expectedHash = await (0, _cachebustingsearchparam.computeCacheBustingSearchParam)(routerPrefetch, segmentPrefetchRSCRequest, headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER], headers[_approuterheaders.NEXT_URL]);
             const actualHash = (0, _requestmeta.getRequestMeta)(req, 'cacheBustingSearchParam') ?? new URL(req.url || '', 'http://localhost').searchParams.get(_approuterheaders.NEXT_RSC_UNION_QUERY);
-            if (expectedHash !== actualHash) {
+            let matchesHash = expectedHash === actualHash;
+            if (!matchesHash && actualHash !== null) {
+                // We'll fallback to checking the legacy hash format to support clients that do not have a secure context
+                matchesHash = (0, _cachebustingsearchparam.computeLegacyCacheBustingSearchParam)(routerPrefetch, segmentPrefetchRSCRequest, headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER], headers[_approuterheaders.NEXT_URL]) === actualHash;
+            }
+            if (!matchesHash) {
                 // The hash sent by the client does not match the expected value.
                 // Redirect to the URL with the correct cache-busting search param.
                 // This prevents cache poisoning attacks on CDNs that don't respect Vary headers.
+                // We continue to accept the legacy short hash for clients that still
+                // generate the 5-character `_rsc` form.
                 // Note: When no headers are present, expectedHash is empty string and client
                 // must send `_rsc` param, otherwise actualHash is null and hash check fails.
                 const url = new URL(req.url || '', 'http://localhost');
@@ -1278,7 +1286,7 @@ class Server {
         // page load) in the Instant Navigation Testing API. Only applies to
         // document requests (no RSC header) - RSC requests should proceed normally
         // even during a locked scope, with blocking happening on the client side.
-        const hasInstantTestCookie = exposeTestingApi && req.headers[_approuterheaders.RSC_HEADER] === undefined && typeof req.headers.cookie === 'string' && req.headers.cookie.includes(_approuterheaders.NEXT_INSTANT_TEST_COOKIE + '=') && couldSupportPPR;
+        const hasInstantTestCookie = exposeTestingApi && !(0, _isrscrequest.isRSCRequestHeader)(req.headers[_approuterheaders.RSC_HEADER]) && typeof req.headers.cookie === 'string' && req.headers.cookie.includes(_approuterheaders.NEXT_INSTANT_TEST_COOKIE + '=') && couldSupportPPR;
         // This page supports PPR if it is marked as being `PARTIALLY_STATIC` in the
         // prerender manifest and this is an app page.
         const isRoutePPREnabled = couldSupportPPR && (((_this = prerenderManifest.routes[pathname] ?? prerenderManifest.dynamicRoutes[pathname]) == null ? void 0 : _this.renderingMode) === 'PARTIALLY_STATIC' || // Ideally we'd want to check the appConfig to see if this page has PPR

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

@@ -368,6 +368,7 @@ const experimentalSchema = {
         'deterministic'
     ]).optional(),
     turbopackInferModuleSideEffects: _zod.z.boolean().optional(),
+    turbopackServerFastRefresh: _zod.z.boolean().optional(),
     optimizePackageImports: _zod.z.array(_zod.z.string()).optional(),
     optimizeServerReact: _zod.z.boolean().optional(),
     strictRouteTypes: _zod.z.boolean().optional(),
@@ -506,8 +507,16 @@ const configSchema = _zod.z.lazy(()=>_zod.z.strictObject({
                     useLightningcss: _zod.z.boolean().optional()
                 })
             ]),
-            define: _zod.z.record(_zod.z.string(), _zod.z.string()).optional(),
-            defineServer: _zod.z.record(_zod.z.string(), _zod.z.string()).optional(),
+            define: _zod.z.record(_zod.z.string(), _zod.z.union([
+                _zod.z.string(),
+                _zod.z.number(),
+                _zod.z.boolean()
+            ])).optional(),
+            defineServer: _zod.z.record(_zod.z.string(), _zod.z.union([
+                _zod.z.string(),
+                _zod.z.number(),
+                _zod.z.boolean()
+            ])).optional(),
             runAfterProductionCompile: _zod.z.function().returns(_zod.z.promise(_zod.z.void())).optional()
         }).optional(),
         compress: _zod.z.boolean().optional(),

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

@@ -1106,7 +1106,7 @@ async function applyModifyConfig(config, phase, silent) {
             }
             config = await adapterMod.modifyConfig(config, {
                 phase,
-                nextVersion: "16.2.0"
+                nextVersion: "16.2.6"
             });
         }
     }

package/standalone/node_modules/next/dist/server/dev/hot-reloader-turbopack.js

@@ -240,7 +240,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-        version: "16.2.0"
+        version: "16.2.6"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -294,7 +294,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
-        nextVersion: "16.2.0",
+        nextVersion: "16.2.6",
         serverHmr: serverFastRefresh
     }, {
         memoryLimit: (_opts_nextConfig_experimental = opts.nextConfig.experimental) == null ? void 0 : _opts_nextConfig_experimental.turbopackMemoryLimit,
@@ -404,7 +404,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         }
     }, 500);
     function clearRequireCache(key, writtenEndpoint, { force } = {}) {
-        var _currentEntrypoints_app_get;
         if (force) {
             for (const { path, contentHash } of writtenEndpoint.serverPaths){
                 // We ignore source maps
@@ -441,23 +440,21 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         }
         const serverPaths = writtenEndpoint.serverPaths.map(({ path: p })=>(0, _path.join)(distDir, p));
         const { type: entryType, page: entryPage } = (0, _entrykey.splitEntryKey)(key);
-        const isAppPage = entryType === 'app' && ((_currentEntrypoints_app_get = currentEntrypoints.app.get(entryPage)) == null ? void 0 : _currentEntrypoints_app_get.type) === 'app-page';
-        // Server HMR only applies to app router pages since these use the Turbopack runtime.
-        // Currently, this is only app router pages.
-        //
-        // This excludes:
-        //   - Pages Router pages
-        //   - Edge routes
-        //   - Middleware
-        //   - App Router route handlers (route.ts)
-        const usesServerHmr = serverFastRefresh && isAppPage && writtenEndpoint.type !== 'edge';
+        // Server HMR applies to App Router entries built with the Turbopack Node.js
+        // runtime: app pages and regular route handlers. Edge routes, Pages Router
+        // pages, middleware/instrumentation, and metadata routes (manifest.ts,
+        // robots.ts, sitemap.ts, icon.tsx, etc.) are excluded. Metadata routes are
+        // excluded because they serve HTTP responses directly and must re-execute
+        // on every request to pick up file changes; the in-place module update
+        // model of Server HMR does not apply to them.
+        const usesServerHmr = serverFastRefresh && entryType === 'app' && writtenEndpoint.type !== 'edge' && !(0, _ismetadataroute.isMetadataRoute)(entryPage);
         const filesToDelete = [];
         for (const file of serverPaths){
             (0, _renderserver.clearModuleContext)(file);
             const relativePath = (0, _path.relative)(distDir, file);
-            if (// For Pages Router, edge routes, middleware, and manifest files
-            // (e.g., *_client-reference-manifest.js): clear the sharedCache in
-            // evalManifest(), Node.js require.cache, and edge runtime module contexts.
+            if (// For Pages Router, edge routes, middleware, and manifest files:
+            // clear the sharedCache in evalManifest(), Node.js require.cache,
+            // and edge runtime module contexts.
             force || !usesServerHmr || !(serverHmrSubscriptions == null ? void 0 : serverHmrSubscriptions.has(relativePath))) {
                 filesToDelete.push(file);
             }
@@ -1461,6 +1458,11 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 if (typeof __next__clear_chunk_cache__ === 'function') {
                     __next__clear_chunk_cache__();
                 }
+                // Reset the server HMR handler registry. All server runtime chunks are
+                // cleared from require.cache above; when they're next required they'll
+                // re-register into this Map and reinstall the routing dispatcher.
+                ;
+                globalThis.__turbopack_server_hmr_handlers__ = new Map();
                 // Clear all edge contexts
                 await (0, _renderserver.clearAllModuleContexts)();
                 resetFetch();

package/standalone/node_modules/next/dist/server/dev/hot-reloader-webpack.js

@@ -234,7 +234,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "16.2.0"
+            version: "16.2.6"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.

package/standalone/node_modules/next/dist/server/dev/static-paths-worker.js

@@ -21,7 +21,7 @@ const _app = require("../../build/static-paths/app");
 const _pages = require("../../build/static-paths/pages");
 const _createincrementalcache = require("../../export/helpers/create-incremental-cache");
 const _app1 = require("../../shared/lib/router/routes/app");
-async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOptions, locales, defaultLocale, isAppPath, page, isrFlushToDisk, fetchCacheKeyPrefix, cacheMaxMemorySize, requestHeaders, cacheHandler, cacheHandlers, cacheLifeProfiles, nextConfigOutput, buildId, authInterrupts, sriEnabled }) {
+async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOptions, locales, defaultLocale, isAppPath, page, isrFlushToDisk, fetchCacheKeyPrefix, cacheMaxMemorySize, requestHeaders, cacheHandler, cacheHandlers, cacheLifeProfiles, nextConfigOutput, buildId, deploymentId, authInterrupts, sriEnabled }) {
     // this needs to be initialized before loadComponents otherwise
     // "use cache" could be missing it's cache handlers
     await (0, _createincrementalcache.createIncrementalCache)({
@@ -80,6 +80,7 @@ async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOption
             isRoutePPREnabled,
             partialFallbacksEnabled: config.partialFallbacks,
             buildId,
+            deploymentId,
             authInterrupts,
             rootParamKeys
         });

package/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/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.0"}`))}${versionSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.2.6"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }

package/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/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/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/standalone/node_modules/next/dist/server/lib/router-server.js

@@ -125,6 +125,7 @@ async function initialize(opts) {
     let development = undefined;
     let originalFetch = globalThis.fetch;
     if (opts.dev) {
+        var _developmentConfig_experimental;
         const { Telemetry } = require('../../telemetry/storage');
         const telemetry = new Telemetry({
             distDir: _path.default.join(opts.dir, config.distDir)
@@ -139,6 +140,18 @@ async function initialize(opts) {
         const setupDevBundlerSpan = opts.startServerSpan ? opts.startServerSpan.traceChild('setup-dev-bundler') : (0, _trace.trace)('setup-dev-bundler');
         // In development, it's always the complete config.
         let developmentConfig = config;
+        // Resolve the effective serverFastRefresh value.
+        // Both default to enabled (true). CLI takes precedence over config.
+        const cliServerFastRefresh = opts.serverFastRefresh;
+        const configServerFastRefresh = (_developmentConfig_experimental = developmentConfig.experimental) == null ? void 0 : _developmentConfig_experimental.turbopackServerFastRefresh;
+        let effectiveServerFastRefresh;
+        if (cliServerFastRefresh !== undefined && configServerFastRefresh !== undefined && cliServerFastRefresh !== configServerFastRefresh) {
+            _log.warn(`The CLI flag "${cliServerFastRefresh === false ? '--no-server-fast-refresh' : '--server-fast-refresh'}" conflicts with "experimental.turbopackServerFastRefresh: ${configServerFastRefresh}" in your Next.js config. The CLI flag will take precedence.`);
+            effectiveServerFastRefresh = cliServerFastRefresh;
+        } else {
+            // Default to true when neither CLI nor config specifies a value.
+            effectiveServerFastRefresh = cliServerFastRefresh ?? configServerFastRefresh ?? true;
+        }
         let developmentBundler = await setupDevBundlerSpan.traceAsyncFn(()=>setupDevBundler({
                 // Passed here but the initialization of this object happens below, doing the initialization before the setupDev call breaks.
                 renderServer,
@@ -153,7 +166,7 @@ async function initialize(opts) {
                 port: opts.port,
                 onDevServerCleanup: opts.onDevServerCleanup,
                 resetFetch,
-                serverFastRefresh: opts.serverFastRefresh
+                serverFastRefresh: effectiveServerFastRefresh
             }));
         let devBundlerService = new _devbundlerservice.DevBundlerService(developmentBundler, // The request handler is assigned below, this allows us to create a lazy
         // reference to it.
@@ -645,7 +658,7 @@ async function initialize(opts) {
                     });
                 }
             });
-            const { matchedOutput, parsedUrl } = await resolveRoutes({
+            const { finished, matchedOutput, parsedUrl, statusCode } = await resolveRoutes({
                 req,
                 res,
                 isUpgradeReq: true,
@@ -656,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/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/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/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.0"})`;
+    process.title = `next-server (v${"16.2.6"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{

package/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