@sifxprime/krouter 0.5.166 → 0.5.167

package/app/node_modules/next/dist/server/load-components.js

@@ -82,6 +82,11 @@ async function loadClientReferenceManifestForPage(distDir, page, attempts) {
         return undefined;
     }
 }
+function loadRouteModule(page, distDir, isAppPath) {
+    return (0, _tracer.getTracer)().trace(_constants1.LoadComponentsSpan.loadRouteModule, {
+        spanName: 'load route module'
+    }, ()=>(0, _require.requirePage)(page, distDir, isAppPath));
+}
 async function loadComponentsImpl({ distDir, page, isAppPath, isDev, sriEnabled, // When route modules are used, which is the case for the server calls to loadComponents, it no longer needs manifest to be loaded here.
 // Static generation still needs the manifests to be loaded here.
 // In the future static generation will also use route modules, and we will remove this flag.
@@ -135,7 +140,7 @@ needsManifestsForLegacyReasons }) {
                 serverActionsManifest
             });
         }
-        const ComponentMod = await (0, _require.requirePage)(page, distDir, isAppPath);
+        const ComponentMod = await loadRouteModule(page, distDir, isAppPath);
         const Component = (0, _interopdefault.interopDefault)(ComponentMod);
         const Document = (0, _interopdefault.interopDefault)(DocumentMod);
         const App = (0, _interopdefault.interopDefault)(AppMod);
@@ -160,7 +165,7 @@ needsManifestsForLegacyReasons }) {
             routeModule
         };
     } else {
-        const ComponentMod = await (0, _require.requirePage)(page, distDir, isAppPath);
+        const ComponentMod = await loadRouteModule(page, distDir, isAppPath);
         const Component = (0, _interopdefault.interopDefault)(ComponentMod);
         const Document = (0, _interopdefault.interopDefault)(DocumentMod);
         const App = (0, _interopdefault.interopDefault)(AppMod);

package/app/node_modules/next/dist/server/load-manifest.external.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     clearManifestCache: null,
     evalManifest: null,
+    evalManifestFromRelativePath: null,
     loadManifest: null,
     loadManifestFromRelativePath: null
 });
@@ -21,6 +22,9 @@ _export(exports, {
     evalManifest: function() {
         return evalManifest;
     },
+    evalManifestFromRelativePath: function() {
+        return evalManifestFromRelativePath;
+    },
     loadManifest: function() {
         return loadManifest;
     },
@@ -34,16 +38,15 @@ const _vm = require("vm");
 const _deepfreeze = require("../shared/lib/deep-freeze");
 const sharedCache = new Map();
 function loadManifest(path, shouldCache = true, cache = sharedCache, skipParse = false, handleMissing) {
-    const cached = shouldCache && cache.get(path);
-    if (cached) {
-        return cached;
+    if (shouldCache && cache.has(path)) {
+        return cache.get(path);
     }
     let manifest;
     if (handleMissing) {
         try {
             manifest = (0, _fs.readFileSync)(/* turbopackIgnore: true */ path, 'utf8');
         } catch (err) {
-            let result = {};
+            let result = undefined;
             cache.set(path, result);
             return result;
         }
@@ -63,16 +66,15 @@ function loadManifest(path, shouldCache = true, cache = sharedCache, skipParse =
     return manifest;
 }
 function evalManifest(path, shouldCache = true, cache = sharedCache, handleMissing) {
-    const cached = shouldCache && cache.get(path);
-    if (cached) {
-        return cached;
+    if (shouldCache && cache.has(path)) {
+        return cache.get(path);
     }
     let content;
     if (handleMissing) {
         try {
             content = (0, _fs.readFileSync)(/* turbopackIgnore: true */ path, 'utf8');
         } catch (err) {
-            let result = {};
+            let result = undefined;
             cache.set(path, result);
             return result;
         }
@@ -80,11 +82,7 @@ function evalManifest(path, shouldCache = true, cache = sharedCache, handleMissi
         content = (0, _fs.readFileSync)(/* turbopackIgnore: true */ path, 'utf8');
     }
     if (content.length === 0) {
-        throw Object.defineProperty(new Error('Manifest file is empty'), "__NEXT_ERROR_CODE", {
-            value: "E328",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Manifest file is empty');
     }
     let contextObject = {
         process: {
@@ -103,11 +101,12 @@ function evalManifest(path, shouldCache = true, cache = sharedCache, handleMissi
     }
     return contextObject;
 }
-function loadManifestFromRelativePath({ projectDir, distDir, manifest, shouldCache, cache, skipParse, handleMissing, useEval }) {
+function evalManifestFromRelativePath({ projectDir, distDir, manifest, shouldCache, cache, handleMissing }) {
+    const manifestPath = (0, _path.join)(/* turbopackIgnore: true */ projectDir, distDir, manifest);
+    return evalManifest(manifestPath, shouldCache, cache, handleMissing);
+}
+function loadManifestFromRelativePath({ projectDir, distDir, manifest, shouldCache, cache, skipParse, handleMissing }) {
     const manifestPath = (0, _path.join)(/* turbopackIgnore: true */ projectDir, distDir, manifest);
-    if (useEval) {
-        return evalManifest(manifestPath, shouldCache, cache, handleMissing);
-    }
     return loadManifest(manifestPath, shouldCache, cache, skipParse, handleMissing);
 }
 function clearManifestCache(path, cache = sharedCache) {

package/app/node_modules/next/dist/server/mcp/tools/utils/browser-communication.js

@@ -43,11 +43,7 @@ function createBrowserRequest(messageType, sendHmrMessage, getActiveConnectionCo
             if (pending && pending.responses.length > 0) {
                 resolve(pending.responses);
             } else {
-                reject(Object.defineProperty(new Error(`Timeout waiting for response from frontend. The browser may not be responding to HMR messages.`), "__NEXT_ERROR_CODE", {
-                    value: "E825",
-                    enumerable: false,
-                    configurable: true
-                }));
+                reject(new Error(`Timeout waiting for response from frontend. The browser may not be responding to HMR messages.`));
             }
             pendingRequests.delete(requestId);
         }, timeoutMs);
@@ -67,11 +63,7 @@ function createBrowserRequest(messageType, sendHmrMessage, getActiveConnectionCo
 }
 function handleBrowserPageResponse(requestId, data, url) {
     if (!url) {
-        throw Object.defineProperty(new Error('URL is required in MCP browser response. This is a bug in Next.js.'), "__NEXT_ERROR_CODE", {
-            value: "E824",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('URL is required in MCP browser response. This is a bug in Next.js.');
     }
     const pending = pendingRequests.get(requestId);
     if (pending) {

package/app/node_modules/next/dist/server/mcp/tools/utils/format-errors.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     formatErrors: null,
+    resolveStackFrames: null,
     setStackFrameResolver: null
 });
 function _export(target, all) {
@@ -16,6 +17,9 @@ _export(exports, {
     formatErrors: function() {
         return formatErrors;
     },
+    resolveStackFrames: function() {
+        return resolveStackFrames;
+    },
     setStackFrameResolver: function() {
         return setStackFrameResolver;
     }
@@ -28,11 +32,7 @@ function setStackFrameResolver(fn) {
 }
 async function resolveStackFrames(request) {
     if (!stackFrameResolver) {
-        throw Object.defineProperty(new Error('Stack frame resolver not initialized. This is a bug in Next.js.'), "__NEXT_ERROR_CODE", {
-            value: "E822",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Stack frame resolver not initialized. This is a bug in Next.js.');
     }
     return stackFrameResolver(request);
 }

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

@@ -13,8 +13,10 @@ require("./node-environment");
 require("./require-hook");
 require("./node-polyfill-crypto");
 const _utils = require("../shared/lib/utils");
+const _devrendercontext = require("./route-modules/app-page/dev-render-context");
 const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 const _path = require("path");
+const _url = require("url");
 const _routematcher = require("../shared/lib/router/utils/route-matcher");
 const _requestmeta = require("./request-meta");
 const _constants = require("../shared/lib/constants");
@@ -27,6 +29,7 @@ const _baseserver = /*#__PURE__*/ _interop_require_default(_export_star(require(
 const _require = require("./require");
 const _denormalizepagepath = require("../shared/lib/page-path/denormalize-page-path");
 const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
+const _apppaths = require("../shared/lib/router/utils/app-paths");
 const _loadcomponents = require("./load-components");
 const _iserror = /*#__PURE__*/ _interop_require_wildcard(require("../lib/is-error"));
 const _utils1 = require("./web/utils");
@@ -39,7 +42,6 @@ const _bodystreams = require("./body-streams");
 const _apiutils = require("./api-utils");
 const _responsecache = /*#__PURE__*/ _interop_require_wildcard(require("./response-cache"));
 const _incrementalcache = require("./lib/incremental-cache");
-const _apppaths = require("../shared/lib/router/utils/app-paths");
 const _setuphttpagentenv = require("./setup-http-agent-env");
 const _pagesapiroutematch = require("./route-matches/pages-api-route-match");
 const _tracer = require("./lib/trace/tracer");
@@ -52,6 +54,7 @@ const _approuterheaders = require("../client/components/app-router-headers");
 const _nextrequest = require("./web/spec-extension/adapters/next-request");
 const _loadmanifestexternal = require("./load-manifest.external");
 const _modulerender = require("./route-modules/app-page/module.render");
+const _parserequestheaders = require("./route-modules/app-page/parse-request-headers");
 const _modulerender1 = require("./route-modules/pages/module.render");
 const _interopdefault = require("../lib/interop-default");
 const _formatdynamicimportpath = require("../lib/format-dynamic-import-path");
@@ -136,11 +139,7 @@ function getMiddlewareMatcher(info) {
         return stored;
     }
     if (!Array.isArray(info.matchers)) {
-        throw Object.defineProperty(new Error(`Invariant: invalid matchers for middleware ${JSON.stringify(info)}`), "__NEXT_ERROR_CODE", {
-            value: "E257",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant: invalid matchers for middleware ${JSON.stringify(info)}`);
     }
     const matcher = (0, _middlewareroutematcher.getMiddlewareRouteMatcher)(info.matchers);
     MiddlewareMatcherCache.set(info, matcher);
@@ -188,11 +187,7 @@ class NextNodeServer extends _baseserver.default {
                 });
                 const { sendResponse, ImageError } = require('./image-optimizer');
                 if (!this.imageResponseCache) {
-                    throw Object.defineProperty(new Error('invariant image optimizer cache was not initialized'), "__NEXT_ERROR_CODE", {
-                        value: "E160",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error('invariant image optimizer cache was not initialized');
                 }
                 const imagesConfig = this.nextConfig.images;
                 if (imagesConfig.loader !== 'default' || imagesConfig.unoptimized) {
@@ -229,12 +224,11 @@ class NextNodeServer extends _baseserver.default {
                         incrementalCache: imageOptimizerCache,
                         isFallback: false
                     });
+                    if (cacheEntry !== null && 'error' in cacheEntry) {
+                        throw cacheEntry.error;
+                    }
                     if ((cacheEntry == null ? void 0 : (_cacheEntry_value = cacheEntry.value) == null ? void 0 : _cacheEntry_value.kind) !== _responsecache.CachedRouteKind.IMAGE) {
-                        throw Object.defineProperty(new Error('invariant did not get entry from image response cache'), "__NEXT_ERROR_CODE", {
-                            value: "E518",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new Error('invariant did not get entry from image response cache');
                     }
                     sendResponse(req.originalRequest, res.originalResponse, paramsResult.href, cacheEntry.value.extension, cacheEntry.value.buffer, cacheEntry.value.etag, paramsResult.isStatic, cacheEntry.isMiss ? 'MISS' : cacheEntry.isStale ? 'STALE' : 'HIT', imagesConfig, ((_cacheEntry_cacheControl = cacheEntry.cacheControl) == null ? void 0 : _cacheEntry_cacheControl.revalidate) || 0, Boolean(this.dev));
                     return true;
@@ -250,11 +244,7 @@ class NextNodeServer extends _baseserver.default {
         }, this.handleCatchallRenderRequest = async (req, res, parsedUrl)=>{
             let { pathname, query } = parsedUrl;
             if (!pathname) {
-                throw Object.defineProperty(new Error('Invariant: pathname is undefined'), "__NEXT_ERROR_CODE", {
-                    value: "E409",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('Invariant: pathname is undefined');
             }
             // When in minimal mode we do not bubble the fallback as the
             // router-server is not present to handle the error
@@ -268,20 +258,32 @@ class NextNodeServer extends _baseserver.default {
             const existingServerContext = _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir];
             if (!existingServerContext) {
                 _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir] = {
-                    render404: this.render404.bind(this)
+                    render404: this.render404.bind(this),
+                    getAssetPrefix: this.getAssetPrefix.bind(this)
                 };
             }
             _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir].nextConfig = this.nextConfig;
             _routerservercontext.routerServerGlobal[_routerservercontext.RouterServerContextSymbol][relativeProjectDir].isWrappedByNextServer = true;
             try {
-                var _this_i18nProvider;
                 // next.js core assumes page path without trailing slash
                 pathname = (0, _removetrailingslash.removeTrailingSlash)(pathname);
-                const options = {
-                    i18n: (_this_i18nProvider = this.i18nProvider) == null ? void 0 : _this_i18nProvider.fromRequest(req, pathname)
-                };
-                const match = await this.matchers.match(pathname, options);
-                // If we don't have a match, try to render it anyways.
+                let match = (0, _requestmeta.getRequestMeta)(req, 'match');
+                // router-server normally attaches the fsChecker match. Direct internal
+                // requests, such as on-demand revalidation, bypass router-server and need
+                // to resolve the route from the manifests here.
+                if (!match) {
+                    var _this_i18nProvider;
+                    const localeAnalysisResult = (_this_i18nProvider = this.i18nProvider) == null ? void 0 : _this_i18nProvider.analyze(pathname, {
+                        defaultLocale: (0, _requestmeta.getRequestMeta)(req, 'defaultLocale')
+                    });
+                    const routeMatch = this.getRouteMatch(pathname, localeAnalysisResult);
+                    if (routeMatch) {
+                        match = routeMatch;
+                    }
+                }
+                // The matcher manager previously fell through to render for unknown
+                // paths. Preserve that behavior for direct render-server requests that do
+                // not pass through fsChecker.
                 if (!match) {
                     await this.render(req, res, pathname, query, parsedUrl, true);
                     return true;
@@ -398,11 +400,7 @@ class NextNodeServer extends _baseserver.default {
                 if ('response' in result) {
                     if (isMiddlewareInvoke) {
                         bubblingResult = true;
-                        throw Object.defineProperty(new _tracer.BubbledError(true, result), "__NEXT_ERROR_CODE", {
-                            value: "E394",
-                            enumerable: false,
-                            configurable: true
-                        });
+                        throw new _tracer.BubbledError(true, result);
                     }
                     for (const [key, value] of Object.entries((0, _utils1.toNodeOutgoingHttpHeaders)(result.response.headers))){
                         if (key !== 'content-encoding' && value !== undefined) {
@@ -468,7 +466,10 @@ class NextNodeServer extends _baseserver.default {
             });
         }
         if (!options.dev && !this.minimalMode && this.nextConfig.experimental.preloadEntriesOnStart) {
-            this.unstable_preloadEntries();
+            // Preloading may join a failing registration started by a request.
+            void this.unstable_preloadEntries().catch((err)=>{
+                _log.error('Failed to preload entries:', err);
+            });
         }
         if (!options.dev) {
             const { dynamicRoutes = [] } = this.getRoutesManifest() ?? {};
@@ -561,12 +562,8 @@ class NextNodeServer extends _baseserver.default {
                 this.instrumentation = await (0, _instrumentationglobalsexternal.getInstrumentationModule)(this.dir, this.nextConfig.distDir);
             } catch (err) {
                 if (err.code !== 'MODULE_NOT_FOUND') {
-                    throw Object.defineProperty(new Error('An error occurred while loading the instrumentation hook', {
+                    throw new Error('An error occurred while loading the instrumentation hook', {
                         cause: err
-                    }), "__NEXT_ERROR_CODE", {
-                        value: "E92",
-                        enumerable: false,
-                        configurable: true
                     });
                 }
             }
@@ -588,13 +585,13 @@ class NextNodeServer extends _baseserver.default {
     async loadCustomCacheHandlers() {
         const { cacheMaxMemorySize, cacheHandlers } = this.nextConfig;
         if (!cacheHandlers) return;
-        // If we've already initialized the cache handlers interface, don't do it
-        // again.
-        if (!(0, _handlers.initializeCacheHandlers)(cacheMaxMemorySize)) return;
-        for (const [kind, handler] of Object.entries(cacheHandlers)){
-            if (!handler) continue;
-            (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
-        }
+        (0, _handlers.initializeCacheHandlers)(cacheMaxMemorySize);
+        await (0, _handlers.registerCustomCacheHandlers)(async ()=>{
+            for (const [kind, handler] of Object.entries(cacheHandlers)){
+                if (!handler) continue;
+                (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+            }
+        });
     }
     async getIncrementalCache({ requestHeaders }) {
         var _this_nextConfig_i18n;
@@ -618,7 +615,8 @@ class NextNodeServer extends _baseserver.default {
             fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
             maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
             flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
-            getPrerenderManifest: ()=>this.getPrerenderManifest(),
+            previewProps: this.getPreviewProps(),
+            prerenderManifest: this.getPrerenderManifest(),
             locales: (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales,
             CurCacheHandler: CacheHandler
         });
@@ -651,11 +649,7 @@ class NextNodeServer extends _baseserver.default {
             return _fs.default.readFileSync(/* turbopackIgnore: true */ buildIdFile, 'utf8').trim();
         } catch (err) {
             if (err.code === 'ENOENT') {
-                throw Object.defineProperty(new Error(`Could not find a production build in the '${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id`), "__NEXT_ERROR_CODE", {
-                    value: "E427",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(`Could not find a production build in the '${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id`);
             }
             throw err;
         }
@@ -699,7 +693,10 @@ class NextNodeServer extends _baseserver.default {
         const parsedInitUrl = (0, _parseurl.parseUrl)((0, _requestmeta.getRequestMeta)(req, 'initURL') || req.url);
         req.url = `${parsedInitUrl.pathname}${parsedInitUrl.search || ''}`;
         const loader = new _nodemoduleloader.NodeModuleLoader();
-        const module = await loader.load(match.definition.filename);
+        // Dev definitions retain source filenames for watcher bookkeeping. API
+        // execution still needs to load the compiled server bundle.
+        const modulePath = this.isDev ? (0, _path.join)(this.distDir, 'server', `${match.definition.bundlePath}.js`) : match.definition.filename;
+        const module = await loader.load(modulePath);
         (0, _requestmeta.addRequestMeta)(req.originalRequest, 'relativeProjectDir', (0, _path.relative)(process.cwd(), this.dir));
         (0, _requestmeta.addRequestMeta)(req.originalRequest, 'distDir', this.distDir);
         await module.handler(req.originalRequest, res.originalResponse, {
@@ -712,16 +709,12 @@ class NextNodeServer extends _baseserver.default {
         });
         return true;
     }
-    async renderHTML(req, res, pathname, query, renderOpts) {
-        return (0, _tracer.getTracer)().trace(_constants1.NextNodeServerSpan.renderHTML, async ()=>this.renderHTMLImpl(req, res, pathname, query, renderOpts));
+    async renderHTML(req, res, pathname, query, renderOpts, routeMatch) {
+        return (0, _tracer.getTracer)().trace(_constants1.NextNodeServerSpan.renderHTML, async ()=>this.renderHTMLImpl(req, res, pathname, query, renderOpts, routeMatch));
     }
-    async renderHTMLImpl(req, res, pathname, query, renderOpts) {
+    async renderHTMLImpl(req, res, pathname, query, renderOpts, routeMatch) {
         if (process.env.NEXT_MINIMAL) {
-            throw Object.defineProperty(new Error('Invariant: renderHTML should not be called in minimal mode'), "__NEXT_ERROR_CODE", {
-                value: "E472",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Invariant: renderHTML should not be called in minimal mode');
         // the `else` branch is needed for tree-shaking
         } else {
             // Due to the way we pass data by mutating `renderOpts`, we can't extend the
@@ -729,13 +722,24 @@ class NextNodeServer extends _baseserver.default {
             // https://github.com/vercel/next.js/blob/df7cbd904c3bd85f399d1ce90680c0ecf92d2752/packages/next/server/render.tsx#L947-L952
             renderOpts.nextFontManifest = this.nextFontManifest;
             if (this.enabledDirectories.app && renderOpts.isAppPath) {
-                return (0, _modulerender.lazyRenderAppPage)(req, res, pathname, query, // This code path does not service revalidations for unknown param
+                var _renderOpts_previewProps;
+                const renderAppPage = !renderOpts.supportsDynamicResponse && !renderOpts.isDraftMode && !renderOpts.isPossibleServerAction ? _modulerender.lazyPrerenderAppPage : _modulerender.lazyRenderAppPage;
+                const dev = (0, _devrendercontext.createDevRenderContext)(req, process.env.__NEXT_DEV_SERVER ? this.getServerComponentsHmrCache() : undefined);
+                const parsedRequestHeaders = (0, _parserequestheaders.parseRequestHeaders)(req.headers, {
+                    isRoutePPREnabled: renderOpts.experimental.isRoutePPREnabled === true,
+                    previewModeId: (_renderOpts_previewProps = renderOpts.previewProps) == null ? void 0 : _renderOpts_previewProps.previewModeId
+                });
+                const result = await renderAppPage(req, res, pathname, query, // This code path does not service revalidations for unknown param
                 // shells. As a result, we don't need to pass in the unknown params.
-                null, renderOpts, this.getServerComponentsHmrCache(), {
+                null, renderOpts, dev, {
                     buildId: this.buildId,
                     deploymentId: this.deploymentId,
                     clientAssetToken: this.nextConfig.supportsImmutableAssets ? '' : this.deploymentId
-                });
+                }, routeMatch, parsedRequestHeaders);
+                if ('error' in result) {
+                    throw result.error;
+                }
+                return result;
             } else {
                 // TODO: re-enable this once we've refactored to use implicit matches
                 // throw new Error('Invariant: render should have used routeModule')
@@ -754,27 +758,15 @@ class NextNodeServer extends _baseserver.default {
     }
     async imageOptimizer(req, res, paramsResult, previousCacheEntry) {
         if (process.env.NEXT_MINIMAL) {
-            throw Object.defineProperty(new Error('invariant: imageOptimizer should not be called in minimal mode'), "__NEXT_ERROR_CODE", {
-                value: "E506",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('invariant: imageOptimizer should not be called in minimal mode');
         } else {
             const { imageOptimizer, fetchExternalImage, fetchInternalImage } = require('./image-optimizer');
             const handleInternalReq = async (newReq, newRes)=>{
                 if (newReq.url === req.url) {
-                    throw Object.defineProperty(new Error(`Invariant attempted to optimize _next/image itself`), "__NEXT_ERROR_CODE", {
-                        value: "E496",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Invariant attempted to optimize _next/image itself`);
                 }
                 if (!this.routerServerHandler) {
-                    throw Object.defineProperty(new Error(`Invariant missing routerServerHandler`), "__NEXT_ERROR_CODE", {
-                        value: "E317",
-                        enumerable: false,
-                        configurable: true
-                    });
+                    throw new Error(`Invariant missing routerServerHandler`);
                 }
                 await this.routerServerHandler(newReq, newRes);
                 return;
@@ -806,6 +798,7 @@ class NextNodeServer extends _baseserver.default {
             const isAppPath = Array.isArray(appPaths);
             let page = ctx.pathname;
             if (isAppPath) {
+                // When it's an array, we need to pass all parallel routes to the loader.
                 page = (0, _apppaths.selectAppPageEntry)(ctx.pathname, appPaths);
             }
             for (const edgeFunctionsPage of edgeFunctionsPages){
@@ -882,19 +875,11 @@ class NextNodeServer extends _baseserver.default {
     }
     // Used in development only, overloaded in next-dev-server
     logErrorWithOriginalStack(_err, _type) {
-        throw Object.defineProperty(new Error('Invariant: logErrorWithOriginalStack can only be called on the development server'), "__NEXT_ERROR_CODE", {
-            value: "E6",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant: logErrorWithOriginalStack can only be called on the development server');
     }
     // Used in development only, overloaded in next-dev-server
     async ensurePage(_opts) {
-        throw Object.defineProperty(new Error('Invariant: ensurePage can only be called on the development server'), "__NEXT_ERROR_CODE", {
-            value: "E291",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant: ensurePage can only be called on the development server');
     }
     /**
    * Resolves `API` request, in development builds on demand
@@ -951,18 +936,52 @@ class NextNodeServer extends _baseserver.default {
         await handler(new _node.NodeNextRequest(mocked.req), new _node.NodeNextResponse(mocked.res));
         await mocked.res.hasStreamed;
         if (mocked.res.getHeader('x-nextjs-cache') !== 'REVALIDATED' && mocked.res.statusCode !== 200 && !(mocked.res.statusCode === 404 && opts.unstable_onlyGenerated)) {
-            throw Object.defineProperty(new Error(`Invalid response ${mocked.res.statusCode}`), "__NEXT_ERROR_CODE", {
-                value: "E175",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`Invalid response ${mocked.res.statusCode}`);
         }
     }
     async render(req, res, pathname, query, parsedUrl, internal = false) {
         return super.render(this.normalizeReq(req), this.normalizeRes(res), pathname, query, parsedUrl, internal);
     }
     async renderToHTML(req, res, pathname, query) {
-        return super.renderToHTML(this.normalizeReq(req), this.normalizeRes(res), pathname, query);
+        const normalizedRes = this.normalizeRes(res);
+        const normalizedReq = this.normalizeReq(req);
+        normalizedReq.url = (0, _url.format)({
+            pathname,
+            query
+        });
+        if (this.dev) {
+            await this.ensurePage({
+                page: pathname,
+                clientOnly: false,
+                url: normalizedReq.url
+            });
+        }
+        // renderToHTML returns the body to legacy custom servers. Route modules
+        // write to the response, so capture their output instead of sending it.
+        const mockedRes = new _mockrequest.MockedResponse({
+            headers: normalizedRes.getHeaders(),
+            statusCode: normalizedRes.statusCode,
+            socket: normalizedRes.originalResponse.socket
+        });
+        const result = await super.renderToHTML(normalizedReq, this.normalizeRes(mockedRes), pathname, query);
+        if (result === null && mockedRes.isSent) {
+            await mockedRes.hasStreamed;
+        }
+        const mockedHeaders = mockedRes.getHeaders();
+        for(const key in mockedHeaders){
+            const value = mockedHeaders[key];
+            if (value !== undefined) {
+                normalizedRes.setHeader(key, Array.isArray(value) ? value.map(String) : String(value));
+            }
+        }
+        normalizedRes.statusCode = mockedRes.statusCode;
+        if (result !== null) {
+            return result;
+        }
+        if (mockedRes.buffers.length > 0) {
+            return Buffer.concat(mockedRes.buffers).toString('utf8');
+        }
+        return null;
     }
     async renderErrorToResponseImpl(ctx, err) {
         const { req, res, query } = ctx;
@@ -1120,11 +1139,7 @@ class NextNodeServer extends _baseserver.default {
    * and errors with rich traces.
    */ async runMiddleware(params) {
         if (process.env.NEXT_MINIMAL) {
-            throw Object.defineProperty(new Error('invariant: runMiddleware should not be called in minimal mode'), "__NEXT_ERROR_CODE", {
-                value: "E276",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('invariant: runMiddleware should not be called in minimal mode');
         }
         // Middleware is skipped for on-demand revalidate requests
         if ((0, _apiutils.checkIsOnDemandRevalidate)(params.request.headers, this.renderOpts.previewProps).isOnDemandRevalidate) {
@@ -1146,11 +1161,7 @@ class NextNodeServer extends _baseserver.default {
             url = `${(0, _requestmeta.getRequestMeta)(params.request, 'initProtocol')}://${this.fetchHostname || 'localhost'}:${this.port}${locale ? `/${locale}` : ''}${params.parsed.pathname}${query ? `?${query}` : ''}`;
         }
         if (!url.startsWith('http')) {
-            throw Object.defineProperty(new Error('To use middleware you must provide a `hostname` and `port` to the Next.js Server'), "__NEXT_ERROR_CODE", {
-                value: "E35",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('To use middleware you must provide a `hostname` and `port` to the Next.js Server');
         }
         const page = {};
         const middleware = await this.getMiddleware();
@@ -1259,11 +1270,18 @@ class NextNodeServer extends _baseserver.default {
         return result;
     }
     getPrerenderManifest() {
-        if (this._cachedPreviewManifest) {
-            return this._cachedPreviewManifest;
+        if (this._cachedPrerenderManifest) {
+            return this._cachedPrerenderManifest;
         }
-        this._cachedPreviewManifest = (0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.PRERENDER_MANIFEST));
-        return this._cachedPreviewManifest;
+        this._cachedPrerenderManifest = (0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.PRERENDER_MANIFEST));
+        return this._cachedPrerenderManifest;
+    }
+    getPreviewProps() {
+        if (this._cachedPreviewPropsManifest) {
+            return this._cachedPreviewPropsManifest;
+        }
+        this._cachedPreviewPropsManifest = (0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, 'server', _constants.PREVIEW_PROPS_MANIFEST));
+        return this._cachedPreviewPropsManifest;
     }
     getPrefetchHints() {
         if (this._cachedPrefetchHints) {
@@ -1295,11 +1313,7 @@ class NextNodeServer extends _baseserver.default {
     }
     async runEdgeFunction(params) {
         if (process.env.NEXT_MINIMAL) {
-            throw Object.defineProperty(new Error('Middleware is not supported in minimal mode. Please remove the `NEXT_MINIMAL` environment variable.'), "__NEXT_ERROR_CODE", {
-                value: "E58",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('Middleware is not supported in minimal mode. Please remove the `NEXT_MINIMAL` environment variable.');
         }
         let edgeInfo;
         const { query, page, match } = params;
@@ -1329,11 +1343,7 @@ class NextNodeServer extends _baseserver.default {
         initialUrl.search = queryString;
         const url = initialUrl.toString();
         if (!url.startsWith('http')) {
-            throw Object.defineProperty(new Error('To use middleware you must provide a `hostname` and `port` to the Next.js Server'), "__NEXT_ERROR_CODE", {
-                value: "E35",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('To use middleware you must provide a `hostname` and `port` to the Next.js Server');
         }
         const { run } = require('./web/sandbox');
         const result = await run({
@@ -1429,11 +1439,7 @@ class NextNodeServer extends _baseserver.default {
     }
     createInternalWaitUntil() {
         if (this.minimalMode) {
-            throw Object.defineProperty(new _invarianterror.InvariantError('createInternalWaitUntil should never be called in minimal mode'), "__NEXT_ERROR_CODE", {
-                value: "E540",
-                enumerable: false,
-                configurable: true
-            });
+            throw new _invarianterror.InvariantError('createInternalWaitUntil should never be called in minimal mode');
         }
         const awaiter = new _awaiter.AwaiterOnce({
             onError: console.error