@claudeye/linux-arm64 1.0.6-beta.1 → 1.0.6-beta.3

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

@@ -55,19 +55,19 @@ const _modulerender = require("./route-modules/app-page/module.render");
 const _modulerender1 = require("./route-modules/pages/module.render");
 const _interopdefault = require("../lib/interop-default");
 const _formatdynamicimportpath = require("../lib/format-dynamic-import-path");
-const _generateinterceptionroutesrewrites = require("../lib/generate-interception-routes-rewrites");
+const _isinterceptionrouterewrite = require("../lib/is-interception-route-rewrite");
 const _routekind = require("./route-kind");
 const _invarianterror = require("../shared/lib/invariant-error");
 const _awaiter = require("./after/awaiter");
 const _asynccallbackset = require("./lib/async-callback-set");
 const _handlers = require("./use-cache/handlers");
 const _staticenv = require("../lib/static-env");
-const _ispostpone = require("./lib/router-utils/is-postpone");
 const _nodemoduleloader = require("./lib/module-loader/node-module-loader");
 const _nofallbackerrorexternal = require("../shared/lib/no-fallback-error.external");
 const _instrumentationglobalsexternal = require("./lib/router-utils/instrumentation-globals.external");
 const _routerservercontext = require("./lib/router-utils/router-server-context");
 const _globalbehaviors = require("./node-environment-extensions/global-behaviors");
+const _processerrorhandlers = require("./node-environment-extensions/process-error-handlers");
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
@@ -146,81 +146,6 @@ function getMiddlewareMatcher(info) {
     MiddlewareMatcherCache.set(info, matcher);
     return matcher;
 }
-function installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListeners) {
-    // The conventional wisdom of Node.js and other runtimes is to treat
-    // unhandled errors as fatal and exit the process.
-    //
-    // But Next.js is not a generic JS runtime — it's a specialized runtime for
-    // React Server Components.
-    //
-    // Many unhandled rejections are due to the late-awaiting pattern for
-    // prefetching data. In Next.js it's OK to call an async function without
-    // immediately awaiting it, to start the request as soon as possible
-    // without blocking unncessarily on the result. These can end up
-    // triggering an "unhandledRejection" if it later turns out that the
-    // data is not needed to render the page. Example:
-    //
-    //     const promise = fetchData()
-    //     const shouldShow = await checkCondition()
-    //     if (shouldShow) {
-    //       return <Component promise={promise} />
-    //     }
-    //
-    // In this example, `fetchData` is called immediately to start the request
-    // as soon as possible, but if `shouldShow` is false, then it will be
-    // discarded without unwrapping its result. If it errors, it will trigger
-    // an "unhandledRejection" event.
-    //
-    // Ideally, we would suppress these rejections completely without warning,
-    // because we don't consider them real errors. (TODO: Currently we do warn.)
-    //
-    // But regardless of whether we do or don't warn, we definitely shouldn't
-    // crash the entire process.
-    //
-    // Even a "legit" unhandled error unrelated to prefetching shouldn't
-    // prevent the rest of the page from rendering.
-    //
-    // So, we're going to intentionally override the default error handling
-    // behavior of the outer JS runtime to be more forgiving
-    // Remove any existing "unhandledRejection" and "uncaughtException" handlers.
-    // This is gated behind an experimental flag until we've considered the impact
-    // in various deployment environments. It's possible this may always need to
-    // be configurable.
-    if (shouldRemoveUncaughtErrorAndRejectionListeners) {
-        process.removeAllListeners('uncaughtException');
-        process.removeAllListeners('unhandledRejection');
-    }
-    // Install a new handler to prevent the process from crashing.
-    process.on('unhandledRejection', (reason)=>{
-        if ((0, _ispostpone.isPostpone)(reason)) {
-            // React postpones that are unhandled might end up logged here but they're
-            // not really errors. They're just part of rendering.
-            return;
-        }
-        // Immediately log the error.
-        // TODO: Ideally, if we knew that this error was triggered by application
-        // code, we would suppress it entirely without logging. We can't reliably
-        // detect all of these, but when cacheComponents is enabled, we could suppress
-        // at least some of them by waiting to log the error until after all in-
-        // progress renders have completed. Then, only log errors for which there
-        // was not a corresponding "rejectionHandled" event.
-        console.error(reason);
-    });
-    process.on('rejectionHandled', ()=>{
-    // TODO: See note in the unhandledRejection handler above. In the future,
-    // we may use the "rejectionHandled" event to de-queue an error from
-    // being logged.
-    });
-    // Unhandled exceptions are errors triggered by non-async functions, so this
-    // is unrelated to the late-awaiting pattern. However, for similar reasons,
-    // we still shouldn't crash the process. Just log it.
-    process.on('uncaughtException', (reason)=>{
-        if ((0, _ispostpone.isPostpone)(reason)) {
-            return;
-        }
-        console.error(reason);
-    });
-}
 class NextNodeServer extends _baseserver.default {
     constructor(options){
         var _options_conf_experimental_sri, _options_conf_experimental, _options_conf_experimental1;
@@ -240,9 +165,26 @@ class NextNodeServer extends _baseserver.default {
             // the `else` branch is needed for tree-shaking
             } else {
                 const { ImageOptimizerCache } = require('./image-optimizer');
+                // Load custom cache handler if configured and opt-in via images.customCacheHandler
+                // Cache the handler instance to preserve state across requests
+                if (!this.imageCacheHandler && this.nextConfig.images.customCacheHandler) {
+                    const { cacheHandler } = this.nextConfig;
+                    if (cacheHandler) {
+                        const CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+                        this.imageCacheHandler = new CacheHandler({
+                            dev: !!this.dev,
+                            flushToDisk: this.nextConfig.experimental.isrFlushToDisk,
+                            serverDistDir: this.serverDistDir,
+                            maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                            revalidatedTags: [],
+                            _requestHeaders: {}
+                        });
+                    }
+                }
                 const imageOptimizerCache = new ImageOptimizerCache({
                     distDir: this.distDir,
-                    nextConfig: this.nextConfig
+                    nextConfig: this.nextConfig,
+                    cacheHandler: this.imageCacheHandler
                 });
                 const { sendResponse, ImageError } = require('./image-optimizer');
                 if (!this.imageResponseCache) {
@@ -257,7 +199,7 @@ class NextNodeServer extends _baseserver.default {
                     await this.render404(req, res);
                     return true;
                 }
-                const paramsResult = ImageOptimizerCache.validateParams(req.originalRequest, parsedUrl.query, this.nextConfig, !!this.renderOpts.dev);
+                const paramsResult = ImageOptimizerCache.validateParams(req.originalRequest, parsedUrl.query, this.nextConfig, !!this.dev);
                 if ('errorMessage' in paramsResult) {
                     res.statusCode = 400;
                     res.body(paramsResult.errorMessage).send();
@@ -294,7 +236,7 @@ class NextNodeServer extends _baseserver.default {
                             configurable: true
                         });
                     }
-                    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.renderOpts.dev));
+                    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;
                 } catch (err) {
                     if (err instanceof ImageError) {
@@ -330,6 +272,7 @@ class NextNodeServer extends _baseserver.default {
                 };
             }
             _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
@@ -399,7 +342,7 @@ class NextNodeServer extends _baseserver.default {
                     throw err;
                 }
                 try {
-                    if (this.renderOpts.dev) {
+                    if (this.dev) {
                         const { formatServerError } = require('../lib/format-server-error');
                         formatServerError(err);
                         this.logErrorWithOriginalStack(err);
@@ -497,6 +440,9 @@ class NextNodeServer extends _baseserver.default {
             return result.finished;
         };
         (0, _globalbehaviors.installGlobalBehaviors)(this.nextConfig);
+        // Load prefetch hints from the build output. This must happen before
+        // any render to ensure segment inlining decisions are available.
+        this.renderOpts.prefetchHints = this.getPrefetchHints();
         const isDev = options.dev ?? false;
         this.isDev = isDev;
         this.sriEnabled = Boolean((_options_conf_experimental = options.conf.experimental) == null ? void 0 : (_options_conf_experimental_sri = _options_conf_experimental.sri) == null ? void 0 : _options_conf_experimental_sri.algorithm);
@@ -551,10 +497,12 @@ class NextNodeServer extends _baseserver.default {
         // when using compile mode static env isn't inlined so we
         // need to populate in normal runtime env
         if (this.renderOpts.isExperimentalCompile) {
-            (0, _staticenv.populateStaticEnv)(this.nextConfig, this.renderOpts.deploymentId || '');
+            // immutableAssetToken only works with Turbopack, and `isExperimentalCompile` isn't supported
+            // with that anyway, so we can assign immutableAssetToken to deploymentId here
+            (0, _staticenv.populateStaticEnv)(this.nextConfig, this.deploymentId || '');
         }
         const shouldRemoveUncaughtErrorAndRejectionListeners = Boolean((_options_conf_experimental1 = options.conf.experimental) == null ? void 0 : _options_conf_experimental1.removeUncaughtErrorAndRejectionListeners);
-        installProcessErrorHandlers(shouldRemoveUncaughtErrorAndRejectionListeners);
+        (0, _processerrorhandlers.installProcessErrorHandlers)(shouldRemoveUncaughtErrorAndRejectionListeners);
     }
     async unstable_preloadEntries() {
         // Ensure prepare process will be finished before preloading entries.
@@ -641,7 +589,7 @@ class NextNodeServer extends _baseserver.default {
         }
     }
     async getIncrementalCache({ requestHeaders }) {
-        const dev = !!this.renderOpts.dev;
+        const dev = !!this.dev;
         let CacheHandler;
         const { cacheHandler } = this.nextConfig;
         if (cacheHandler) {
@@ -681,7 +629,7 @@ class NextNodeServer extends _baseserver.default {
     getinterceptionRoutePatterns() {
         if (!this.enabledDirectories.app) return [];
         const routesManifest = this.getRoutesManifest();
-        return (routesManifest == null ? void 0 : routesManifest.rewrites.beforeFiles.filter(_generateinterceptionroutesrewrites.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))) ?? [];
+        return (routesManifest == null ? void 0 : routesManifest.rewrites.beforeFiles.filter(_isinterceptionrouterewrite.isInterceptionRouteRewrite).map((rewrite)=>new RegExp(rewrite.regex))) ?? [];
     }
     async hasPage(pathname) {
         var _this_nextConfig_i18n;
@@ -769,14 +717,17 @@ class NextNodeServer extends _baseserver.default {
                 return (0, _modulerender.lazyRenderAppPage)(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(), {
-                    buildId: this.buildId
+                    buildId: this.buildId,
+                    deploymentId: this.deploymentId,
+                    clientAssetToken: this.nextConfig.experimental.immutableAssetToken ?? this.deploymentId
                 });
             } else {
                 // TODO: re-enable this once we've refactored to use implicit matches
                 // throw new Error('Invariant: render should have used routeModule')
                 return (0, _modulerender1.lazyRenderPagesPage)(req.originalRequest, res.originalResponse, pathname, query, renderOpts, {
                     buildId: this.buildId,
-                    deploymentId: this.renderOpts.deploymentId,
+                    deploymentId: this.deploymentId,
+                    clientAssetToken: this.nextConfig.experimental.immutableAssetToken ?? this.deploymentId,
                     customServer: this.serverOptions.customServer || undefined
                 }, {
                     isFallback: false,
@@ -813,10 +764,19 @@ class NextNodeServer extends _baseserver.default {
                 await this.routerServerHandler(newReq, newRes);
                 return;
             };
-            const { isAbsolute, href } = paramsResult;
-            const imageUpstream = isAbsolute ? await fetchExternalImage(href, this.nextConfig.images.dangerouslyAllowLocalIP, this.nextConfig.images.maximumResponseBody, this.nextConfig.images.maximumRedirects) : await fetchInternalImage(href, req.originalRequest, res.originalResponse, handleInternalReq);
+            let { href } = paramsResult;
+            if (process.env.__NEXT_TEST_MODE && process.env.IS_TURBOPACK_TEST && !paramsResult.isAbsolute) {
+                // Forward the dpl query param from the original /_next/image request to the
+                // internal static file request so that the static file validation in
+                // resolve-routes.ts can verify it.
+                const dpl = typeof req.url === 'string' ? new URL(req.url, 'http://n').searchParams.get('dpl') : undefined;
+                if (dpl) {
+                    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);
             return imageOptimizer(imageUpstream, paramsResult, this.nextConfig, {
-                isDev: this.renderOpts.dev,
+                isDev: this.dev,
                 previousCacheEntry
             });
         }
@@ -968,10 +928,10 @@ class NextNodeServer extends _baseserver.default {
         const handler = super.getRequestHandler();
         return (req, res, parsedUrl)=>handler(this.normalizeReq(req), this.normalizeRes(res), parsedUrl);
     }
-    async revalidate({ urlPath, revalidateHeaders, opts }) {
+    async revalidate({ urlPath, headers, opts }) {
         const mocked = (0, _mockrequest.createRequestResponseMocks)({
             url: urlPath,
-            headers: revalidateHeaders
+            headers
         });
         const handler = this.getRequestHandler();
         await handler(new _node.NodeNextRequest(mocked.req), new _node.NodeNextResponse(mocked.res));
@@ -994,7 +954,7 @@ class NextNodeServer extends _baseserver.default {
         const { req, res, query } = ctx;
         const is404 = res.statusCode === 404;
         if (is404 && this.enabledDirectories.app) {
-            if (this.renderOpts.dev) {
+            if (this.dev) {
                 await this.ensurePage({
                     page: _constants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY,
                     clientOnly: false,
@@ -1106,8 +1066,8 @@ class NextNodeServer extends _baseserver.default {
         if (!process.env.NEXT_MINIMAL) {
             try {
                 var _functionsConfig_functions;
-                const functionsConfig = this.renderOpts.dev ? {} : require((0, _path.join)(/* turbopackIgnore: true */ this.distDir, 'server', _constants.FUNCTIONS_CONFIG_MANIFEST));
-                if (this.renderOpts.dev || (functionsConfig == null ? void 0 : (_functionsConfig_functions = functionsConfig.functions) == null ? void 0 : _functionsConfig_functions['/_middleware'])) {
+                const functionsConfig = this.dev ? {} : require((0, _path.join)(/* turbopackIgnore: true */ this.distDir, 'server', _constants.FUNCTIONS_CONFIG_MANIFEST));
+                if (this.dev || (functionsConfig == null ? void 0 : (_functionsConfig_functions = functionsConfig.functions) == null ? void 0 : _functionsConfig_functions['/_middleware'])) {
                     // if used with top level await, this will be a promise
                     return require((0, _path.join)(/* turbopackIgnore: true */ this.distDir, 'server', 'middleware.js'));
                 }
@@ -1251,10 +1211,11 @@ class NextNodeServer extends _baseserver.default {
                 edgeFunctionEntry: middlewareInfo,
                 request: requestData,
                 useCache: true,
-                onWarning: params.onWarning
+                onWarning: params.onWarning,
+                clientAssetToken: this.nextConfig.experimental.immutableAssetToken || this.deploymentId
             });
         }
-        if (!this.renderOpts.dev) {
+        if (!this.dev) {
             result.waitUntil.catch((error)=>{
                 console.error(`Uncaught: middleware waitUntil errored`, error);
             });
@@ -1286,6 +1247,14 @@ class NextNodeServer extends _baseserver.default {
         this._cachedPreviewManifest = (0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.PRERENDER_MANIFEST));
         return this._cachedPreviewManifest;
     }
+    getPrefetchHints() {
+        if (this._cachedPrefetchHints) {
+            return this._cachedPrefetchHints;
+        }
+        this._cachedPrefetchHints = (0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.SERVER_DIRECTORY, _constants.PREFETCH_HINTS), true, undefined, false, true // handleMissing: don't crash if the file doesn't exist
+        ) ?? {};
+        return this._cachedPrefetchHints;
+    }
     getRoutesManifest() {
         return (0, _tracer.getTracer)().trace(_constants1.NextNodeServerSpan.getRoutesManifest, ()=>(0, _loadmanifestexternal.loadManifest)((0, _path.join)(/* turbopackIgnore: true */ this.distDir, _constants.ROUTES_MANIFEST)));
     }
@@ -1377,7 +1346,8 @@ class NextNodeServer extends _baseserver.default {
             onError: params.onError,
             onWarning: params.onWarning,
             incrementalCache: globalThis.__incrementalCache || (0, _requestmeta.getRequestMeta)(params.req, 'incrementalCache'),
-            serverComponentsHmrCache: (0, _requestmeta.getRequestMeta)(params.req, 'serverComponentsHmrCache')
+            serverComponentsHmrCache: (0, _requestmeta.getRequestMeta)(params.req, 'serverComponentsHmrCache'),
+            clientAssetToken: this.nextConfig.experimental.immutableAssetToken || this.deploymentId
         });
         if (result.fetchMetrics) {
             params.req.fetchMetrics = result.fetchMetrics;
@@ -1422,7 +1392,7 @@ class NextNodeServer extends _baseserver.default {
     async instrumentationOnRequestError(...args) {
         await super.instrumentationOnRequestError(...args);
         // For Node.js runtime production logs, in dev it will be overridden by next-dev-server
-        if (!this.renderOpts.dev) {
+        if (!this.dev) {
             const [err, , , silenceLog] = args;
             if (!silenceLog) {
                 this.logError(err);

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

@@ -290,6 +290,9 @@ class NextServer {
         return this.options.port;
     }
     async prepare() {
+        if (this.options.dev) {
+            process.env.__NEXT_DEV_SERVER = '1';
+        }
         const { getRequestHandlers } = require('./lib/start-server');
         let onDevServerCleanup;
         if (this.options.dev) {

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/console-dim.external.js

@@ -8,10 +8,52 @@ Object.defineProperty(exports, "setAbortedLogsStyle", {
         return setAbortedLogsStyle;
     }
 });
+const _nodeinspector = /*#__PURE__*/ _interop_require_wildcard(require("node:inspector"));
 const _picocolors = require("../../lib/picocolors");
 const _consoleasyncstorageexternal = require("../app-render/console-async-storage.external");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _runtimereactsexternal = require("../runtime-reacts.external");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- we may use later and want parity with the HIDDEN_STYLE value
 const DIMMED_STYLE = 'dimmed';
 const HIDDEN_STYLE = 'hidden';
@@ -115,6 +157,15 @@ function dimmedConsoleArgs(...inputArgs) {
     ];
 }
 function convertToDimmedArgs(methodName, args) {
+    // When the Node.js inspector is open (e.g. --inspect), skip dimming entirely.
+    // Dimming wraps arguments in a format string which defeats inspector
+    // affordances such as collapsible objects and clickable/linkified stack
+    // traces. Ideally we would only skip dimming when a debugger frontend is
+    // actually attached, but Node.js does not expose a synchronous API for that.
+    // Detecting would require async polling of the /json/list HTTP endpoint.
+    if (_nodeinspector.url() !== undefined) {
+        return args;
+    }
     switch(methodName){
         case 'dir':
         case 'dirxml':
@@ -186,13 +237,16 @@ function patchConsoleMethod(methodName) {
                 // to create a cache scope for arbitrary computation and can move over to cacheSignal exclusively.
                 // fallthrough
                 case 'prerender-client':
-                    // This is a react-dom/server render and won't have a cacheSignal until React adds this for the client world.
-                    const renderSignal = workUnitStore.renderSignal;
-                    if (renderSignal.aborted) {
-                        if (currentAbortedLogsStyle === HIDDEN_STYLE) {
-                            return;
+                case 'validation-client':
+                    {
+                        // This is a react-dom/server render and won't have a cacheSignal until React adds this for the client world.
+                        const renderSignal = workUnitStore.renderSignal;
+                        if (renderSignal.aborted) {
+                            if (currentAbortedLogsStyle === HIDDEN_STYLE) {
+                                return;
+                            }
+                            return applyWithDimming.call(this, consoleStore, originalMethod, methodName, args);
                         }
-                        return applyWithDimming.call(this, consoleStore, originalMethod, methodName, args);
                     }
                 // intentional fallthrough
                 case 'prerender-legacy':
@@ -201,6 +255,7 @@ function patchConsoleMethod(methodName) {
                 case 'unstable-cache':
                 case 'private-cache':
                 case 'request':
+                case 'generate-static-params':
                 case undefined:
                     if ((consoleStore == null ? void 0 : consoleStore.dim) === true) {
                         return applyWithDimming.call(this, consoleStore, originalMethod, methodName, args);

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/date.js

@@ -12,11 +12,11 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 function createNow(originalNow) {
     return ({
         now: function now() {
-            (0, _utils.io)('`Date.now()`', 'time');
+            (0, _ioutils.io)('`Date.now()`', 'time');
             return originalNow();
         }
     })['now'.slice()].bind(null);
@@ -29,11 +29,11 @@ function createDate(originalConstructor) {
     const newConstructor = Object.defineProperties(// Ideally this should not minify the name.
     function Date1() {
         if (new.target === undefined) {
-            (0, _utils.io)('`Date()`', 'time');
+            (0, _ioutils.io)('`Date()`', 'time');
             return apply(originalConstructor, undefined, arguments);
         }
         if (arguments.length === 0) {
-            (0, _utils.io)('`new Date()`', 'time');
+            (0, _ioutils.io)('`new Date()`', 'time');
         }
         return construct(originalConstructor, arguments, new.target);
     }, properties);

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/fast-set-immediate.external.js

@@ -34,12 +34,21 @@ var ExecutionState = /*#__PURE__*/ function(ExecutionState) {
     ExecutionState[ExecutionState["Abandoned"] = 4] = "Abandoned";
     return ExecutionState;
 }(ExecutionState || {});
+const FAST_SET_IMMEDIATE_ORIGINALS_KEY = Symbol.for('next.fast-set-immediate.originals');
+// Re-evaluations in dev should always use the same base/original functions.
+const originals = globalThis[FAST_SET_IMMEDIATE_ORIGINALS_KEY] ?? (globalThis[FAST_SET_IMMEDIATE_ORIGINALS_KEY] = {
+    setImmediate: globalThis.setImmediate,
+    clearImmediate: globalThis.clearImmediate,
+    nextTick: process.nextTick
+});
 let wasEnabledAtLeastOnce = false;
 let pendingNextTicks = 0;
 let currentExecution = null;
-const originalSetImmediate = globalThis.setImmediate;
-const originalClearImmediate = globalThis.clearImmediate;
-const originalNextTick = process.nextTick;
+const originalSetImmediate = originals.setImmediate;
+const originalClearImmediate = originals.clearImmediate;
+const originalNextTick = originals.nextTick;
+const originalSetImmediatePromisify = typeof originalSetImmediate === 'function' ? originalSetImmediate[_nodeutil.promisify.custom] : // and won't ever enable the patch, so this can be a dummy value
+undefined;
 function install() {
     if (process.env.NEXT_RUNTIME === 'edge') {
         // Nothing to patch. The exported functions all error if used in the edge runtime,
@@ -442,9 +451,7 @@ function patchedSetImmediate() {
 }
 function patchedSetImmediatePromise(value, options) {
     if (currentExecution === null) {
-        const originalPromisify = // @ts-expect-error: the types for `promisify.custom` are strange
-        originalSetImmediate[_nodeutil.promisify.custom];
-        return originalPromisify(value, options);
+        return originalSetImmediatePromisify(value, options);
     }
     return new Promise((resolve, reject)=>{
         // The abort signal makes the promise reject.

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/{utils.js → io-utils.js}

@@ -87,11 +87,11 @@ function io(expression, type) {
                 break;
             }
         case 'request':
-            if (process.env.NODE_ENV === 'development') {
+            {
                 const stageController = workUnitStore.stagedRendering;
-                if (stageController && stageController.canSyncInterrupt()) {
+                if (stageController && stageController.shouldTrackSyncInterrupt()) {
                     let message;
-                    if (stageController.currentStage === _stagedrendering.RenderStage.Static) {
+                    if (stageController.currentStage === _stagedrendering.RenderStage.Static || stageController.currentStage === _stagedrendering.RenderStage.EarlyStatic) {
                         switch(type){
                             case 'time':
                                 message = `Route "${workStore.route}" used ${expression} before accessing either uncached data (e.g. \`fetch()\`) or Request data (e.g. \`cookies()\`, \`headers()\`, \`connection()\`, and \`searchParams\`). Accessing the current time in a Server Component requires reading one of these data sources first. Alternatively, consider moving this expression into a Client Component or Cache Component. See more info here: https://nextjs.org/docs/messages/next-prerender-current-time`;
@@ -144,14 +144,23 @@ function io(expression, type) {
                         configurable: true
                     }));
                     stageController.syncInterruptCurrentStageWithReason(syncIOError);
+                    // A build-time validation render uses a 'request' store type, but may be abortable.
+                    // If we're in the second, restarted render of the restart-on-cache miss flow,
+                    // Sync IO is an error, and unlike dev, there's no need to continue the render past the sync IO,
+                    // so we can abort it.
+                    if (workUnitStore.controller && !workUnitStore.controller.signal.aborted) {
+                        workUnitStore.controller.abort(syncIOError);
+                    }
                 }
+                break;
             }
-            break;
+        case 'validation-client':
         case 'prerender-ppr':
         case 'prerender-legacy':
         case 'cache':
         case 'private-cache':
         case 'unstable-cache':
+        case 'generate-static-params':
             break;
         default:
             workUnitStore;
@@ -183,4 +192,4 @@ function applyOwnerStack(error) {
     return error;
 }
 
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=io-utils.js.map

package/assets/standalone/node_modules/next/dist/server/node-environment-extensions/node-crypto.js

@@ -9,7 +9,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _utils = require("./utils");
+const _ioutils = require("./io-utils");
 if (process.env.NEXT_RUNTIME === 'edge') {
 // nothing to patch
 } else {
@@ -21,7 +21,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
     try {
         const _randomUUID = nodeCrypto.randomUUID;
         nodeCrypto.randomUUID = function randomUUID() {
-            (0, _utils.io)(randomUUIDExpression, 'random');
+            (0, _ioutils.io)(randomUUIDExpression, 'random');
             return _randomUUID.apply(this, arguments);
         };
     } catch  {
@@ -34,7 +34,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         nodeCrypto.randomBytes = function randomBytes() {
             if (typeof arguments[1] !== 'function') {
                 // randomBytes is sync if the second arg is undefined
-                (0, _utils.io)(randomBytesExpression, 'random');
+                (0, _ioutils.io)(randomBytesExpression, 'random');
             }
             return _randomBytes.apply(this, arguments);
         };
@@ -46,7 +46,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         const _randomFillSync = nodeCrypto.randomFillSync;
         // @ts-expect-error -- TODO: tell TS the overloads are preserved
         nodeCrypto.randomFillSync = function randomFillSync() {
-            (0, _utils.io)(randomFillSyncExpression, 'random');
+            (0, _ioutils.io)(randomFillSyncExpression, 'random');
             return _randomFillSync.apply(this, arguments);
         };
     } catch  {
@@ -59,7 +59,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         nodeCrypto.randomInt = function randomInt() {
             if (typeof arguments[2] !== 'function') {
                 // randomInt is sync if the third arg is undefined
-                (0, _utils.io)(randomIntExpression, 'random');
+                (0, _ioutils.io)(randomIntExpression, 'random');
             }
             return _randomInt.apply(this, arguments);
         };
@@ -71,7 +71,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         const _generatePrimeSync = nodeCrypto.generatePrimeSync;
         // @ts-expect-error -- TODO: tell TS the overloads are preserved
         nodeCrypto.generatePrimeSync = function generatePrimeSync() {
-            (0, _utils.io)(generatePrimeSyncExpression, 'random');
+            (0, _ioutils.io)(generatePrimeSyncExpression, 'random');
             return _generatePrimeSync.apply(this, arguments);
         };
     } catch  {
@@ -82,7 +82,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
         const _generateKeyPairSync = nodeCrypto.generateKeyPairSync;
         // @ts-expect-error -- TODO: tell TS the overloads are preserved
         nodeCrypto.generateKeyPairSync = function generateKeyPairSync() {
-            (0, _utils.io)(generateKeyPairSyncExpression, 'random');
+            (0, _ioutils.io)(generateKeyPairSyncExpression, 'random');
             return _generateKeyPairSync.apply(this, arguments);
         };
     } catch  {
@@ -92,7 +92,7 @@ if (process.env.NEXT_RUNTIME === 'edge') {
     try {
         const _generateKeySync = nodeCrypto.generateKeySync;
         nodeCrypto.generateKeySync = function generateKeySync() {
-            (0, _utils.io)(generateKeySyncExpression, 'random');
+            (0, _ioutils.io)(generateKeySyncExpression, 'random');
             return _generateKeySync.apply(this, arguments);
         };
     } catch  {