@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/server/lib/router-utils/typegen.js

@@ -410,15 +410,44 @@ declare module 'next/form' {
 }
 `;
 }
+// Object literals and unannotated generator returns widen their mode values to
+// string. Runtime validation checks those values; generated types still enforce
+// the parameter scope and mutually exclusive export forms. Users can opt into
+// contextual mode checking with `satisfies ParamMatching` from 'next'.
+const PRERENDER_MATCHER_TYPE_DEFINITIONS = `type ParamMatchFragment<Route extends keyof ParamMap> = Partial<Record<keyof ParamMap[Route], string>>
+type ParamMatchingExports<Route extends keyof ParamMap> =
+  | { unstable_paramMatching?: ParamMatchFragment<Route>; unstable_generateParamMatching?: never }
+  | { unstable_paramMatching?: never; unstable_generateParamMatching?: () => Promise<ParamMatchFragment<Route>> | ParamMatchFragment<Route> }
+
+`;
+function getPrerenderMatcherKeyValidation(route, type) {
+    return route && (type === 'AppPageConfig' || type === 'LayoutConfig') ? `
+  type __ParamMatchingValue =
+    typeof handler extends { unstable_paramMatching: infer Matcher } ? Matcher :
+    typeof handler extends { unstable_generateParamMatching: (...args: any[]) => infer Matcher } ? Awaited<Matcher> : {}
+  type __InvalidParamMatchingKeys = Exclude<keyof __ParamMatchingValue, keyof ParamMap[${JSON.stringify(route)}]>
+  type __AssertNoInvalidParamMatchingKeys<Invalid extends never> = Invalid
+  const __paramMatchingKeyCheck: __AssertNoInvalidParamMatchingKeys<__InvalidParamMatchingKeys> | undefined = undefined
+  void __paramMatchingKeyCheck` : '';
+}
 function generateValidatorFile(routesManifest) {
     const generateValidations = (paths, type, pathToRouteMap)=>paths.sort()// Only validate TypeScript files - JavaScript files have too many type inference limitations
-        .filter((filePath)=>filePath.endsWith('.ts') || filePath.endsWith('.tsx')).filter(// Don't include metadata routes or pages
-        // (e.g. /manifest.webmanifest)
-        (filePath)=>type !== 'AppPageConfig' || filePath.endsWith('page.ts') || filePath.endsWith('page.tsx')).map((filePath)=>{
+        .filter((filePath)=>filePath.endsWith('.ts') || filePath.endsWith('.tsx')).filter((filePath)=>{
+            // Metadata files have different exports from pages and route handlers.
+            if (type === 'AppPageConfig') {
+                return filePath.endsWith('page.ts') || filePath.endsWith('page.tsx');
+            }
+            if (type === 'RouteHandlerConfig') {
+                // Match custom page extensions too, such as route.api.ts.
+                return /(?:^|\/)route\.[^/]+$/.test(filePath);
+            }
+            return true;
+        }).map((filePath)=>{
             // Keep the file extension for TypeScript imports to support node16 module resolution
             const importPath = filePath;
             const route = pathToRouteMap == null ? void 0 : pathToRouteMap.get(filePath);
             const typeWithRoute = route && (type === 'AppPageConfig' || type === 'LayoutConfig' || type === 'RouteHandlerConfig') ? `${type}<${JSON.stringify(route)}>` : type;
+            const matcherKeyValidation = getPrerenderMatcherKeyValidation(route, type);
             // NOTE: we previously used `satisfies` here, but it's not supported by TypeScript 4.8 and below.
             // If we ever raise the TS minimum version, we can switch back.
             return `// Validate ${filePath}
@@ -426,6 +455,7 @@ function generateValidatorFile(routesManifest) {
   type __IsExpected<Specific extends ${typeWithRoute}> = Specific
   const handler = {} as typeof import(${JSON.stringify(importPath.replace(/\.tsx?$/, '.js'))})
   type __Check = __IsExpected<typeof handler>
+  ${matcherKeyValidation}
   // @ts-ignore
   type __Unused = __Check
 }`;
@@ -440,6 +470,9 @@ function generateValidatorFile(routesManifest) {
     const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
     // Build type definitions based on what's actually used
     let typeDefinitions = '';
+    if (appPageValidations || layoutValidations) {
+        typeDefinitions += PRERENDER_MATCHER_TYPE_DEFINITIONS;
+    }
     if (appPageValidations) {
         typeDefinitions += `type AppPageConfig<Route extends AppRoutes = AppRoutes> = {
   default: React.ComponentType<{ params: Promise<ParamMap[Route]> } & any> | ((props: { params: Promise<ParamMap[Route]> } & any) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
@@ -454,7 +487,7 @@ function generateValidatorFile(routesManifest) {
   ) => Promise<any> | any
   metadata?: any
   viewport?: any
-}
+} & ParamMatchingExports<Route>
 
 `;
     }
@@ -492,7 +525,7 @@ function generateValidatorFile(routesManifest) {
   ) => Promise<any> | any
   metadata?: any
   viewport?: any
-}
+} & ParamMatchingExports<Route>
 
 `;
     }
@@ -573,17 +606,27 @@ ${layoutValidations}
 }
 function generateValidatorFileStrict(routesManifest) {
     const generateValidations = (paths, type, pathToRouteMap)=>paths.sort()// Only validate TypeScript files - JavaScript files have too many type inference limitations
-        .filter((filePath)=>filePath.endsWith('.ts') || filePath.endsWith('.tsx')).filter(// Don't include metadata routes or pages
-        // (e.g. /manifest.webmanifest)
-        (filePath)=>type !== 'AppPageConfig' || filePath.endsWith('page.ts') || filePath.endsWith('page.tsx')).map((filePath)=>{
+        .filter((filePath)=>filePath.endsWith('.ts') || filePath.endsWith('.tsx')).filter((filePath)=>{
+            // Metadata files have different exports from pages and route handlers.
+            if (type === 'AppPageConfig') {
+                return filePath.endsWith('page.ts') || filePath.endsWith('page.tsx');
+            }
+            if (type === 'RouteHandlerConfig') {
+                // Match custom page extensions too, such as route.api.ts.
+                return /(?:^|\/)route\.[^/]+$/.test(filePath);
+            }
+            return true;
+        }).map((filePath)=>{
             // Keep the file extension for TypeScript imports to support node16 module resolution
             const importPath = filePath;
             const route = pathToRouteMap == null ? void 0 : pathToRouteMap.get(filePath);
             const typeWithRoute = route && (type === 'AppPageConfig' || type === 'LayoutConfig' || type === 'RouteHandlerConfig') ? `${type}<${JSON.stringify(route)}>` : type;
+            const matcherKeyValidation = getPrerenderMatcherKeyValidation(route, type);
             return `// Validate ${filePath}
 {
   const handler = {} as typeof import(${JSON.stringify(importPath.replace(/\.tsx?$/, '.js'))})
   handler satisfies ${typeWithRoute}
+  ${matcherKeyValidation}
 }`;
         }).join('\n\n');
     // Use direct mappings from the manifest
@@ -596,6 +639,9 @@ function generateValidatorFileStrict(routesManifest) {
     const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
     // Build type definitions based on what's actually used
     let typeDefinitions = '';
+    if (appPageValidations || layoutValidations) {
+        typeDefinitions += PRERENDER_MATCHER_TYPE_DEFINITIONS;
+    }
     if (appPageValidations) {
         typeDefinitions += `type AppPageConfig<Route extends AppRoutes = AppRoutes> = {
   default: React.JSXElementConstructor<PageProps<Route>>
@@ -610,7 +656,7 @@ function generateValidatorFileStrict(routesManifest) {
   ) => Promise<any> | any
   metadata?: any
   viewport?: any
-}
+} & ParamMatchingExports<Route>
 
 `;
     }
@@ -648,7 +694,7 @@ function generateValidatorFileStrict(routesManifest) {
   ) => Promise<any> | any
   metadata?: any
   viewport?: any
-}
+} & ParamMatchingExports<Route>
 
 `;
     }

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

@@ -44,6 +44,7 @@ const _trace = require("../../trace");
 const _isipv6 = require("./is-ipv6");
 const _asynccallbackset = require("./async-callback-set");
 const _durationtostring = require("../../build/duration-to-string");
+const _ciinfo = require("../ci-info");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -143,12 +144,8 @@ let startServerSpan;
                 });
             }
         } catch (cause) {
-            handleError(Object.defineProperty(new Error('Unexpected error during process lookup', {
+            handleError(new Error('Unexpected error during process lookup', {
                 cause
-            }), "__NEXT_ERROR_CODE", {
-                value: "E713",
-                enumerable: false,
-                configurable: true
             }));
         }
     });
@@ -177,7 +174,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.3.8"})`;
+    process.title = `next-server (v${"16.4.1"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{
@@ -189,32 +186,20 @@ async function startServer(serverOptions) {
             await handlersPromise;
             return requestHandler(req, res);
         }
-        throw Object.defineProperty(new Error('Invariant request handler was not setup'), "__NEXT_ERROR_CODE", {
-            value: "E287",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant request handler was not setup');
     };
     let upgradeHandler = async (req, socket, head)=>{
         if (handlersPromise) {
             await handlersPromise;
             return upgradeHandler(req, socket, head);
         }
-        throw Object.defineProperty(new Error('Invariant upgrade handler was not setup'), "__NEXT_ERROR_CODE", {
-            value: "E290",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Invariant upgrade handler was not setup');
     };
     let nextServer;
     let devMemoryThresholdRestart = true;
     // setup server listener as fast as possible
     if (selfSignedCertificate && !isDev) {
-        throw Object.defineProperty(new Error('Using a self signed certificate is only supported with `next dev`.'), "__NEXT_ERROR_CODE", {
-            value: "E128",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Using a self signed certificate is only supported with `next dev`.');
     }
     async function requestListener(req, res) {
         try {
@@ -236,7 +221,7 @@ async function startServer(serverOptions) {
                     'memory.heapSizeLimit': String(memoryRestartStats.heap_size_limit),
                     'memory.heapUsed': String(memoryRestartStats.used_heap_size)
                 }).stop();
-                await (0, _trace.flushAllTraces)();
+                (0, _trace.flushAllTraces)();
                 process.exit(_utils.RESTART_EXIT_CODE);
             }
         }
@@ -347,7 +332,7 @@ async function startServer(serverOptions) {
                             cleanupListeners == null ? void 0 : cleanupListeners.runAll().catch(console.error)
                         ]);
                         // Flush any remaining traces to the trace file on shutdown
-                        await (0, _trace.flushAllTraces)();
+                        (0, _trace.flushAllTraces)();
                         // Flush telemetry if this is a dev server
                         if (isDev) {
                             try {
@@ -357,7 +342,12 @@ async function startServer(serverOptions) {
                                     // Use flushDetached to avoid blocking process exit
                                     // Each process writes to a unique file (_events_${pid}.json)
                                     // to avoid race conditions with the parent process
-                                    telemetry.flushDetached('dev', dir);
+                                    telemetry.flushDetached({
+                                        mode: 'dev',
+                                        dir,
+                                        distDir: null,
+                                        events: null
+                                    });
                                 }
                             } catch (_) {
                             // Ignore telemetry errors during cleanup
@@ -413,19 +403,13 @@ async function startServer(serverOptions) {
                         cacheComponents: initResult.cacheComponents,
                         partialPrefetching: initResult.partialPrefetching
                     });
-                    // Auto-generate AGENTS.md / CLAUDE.md when an AI coding agent
-                    // is detected but the managed agent-rules block is missing.
-                    // Gated on `agentRules` in next.config (default true).
-                    if (initResult.agentRules !== false) {
-                        const result = await (0, _appinfolog.ensureAgentRulesForDev)(dir);
-                        if (result) {
-                            const generated = [];
-                            if (result.agentsMd === 'created' || result.agentsMd === 'updated') generated.push('AGENTS.md');
-                            if (result.claudeMd === 'created' || result.claudeMd === 'updated') generated.push('CLAUDE.md');
-                            if (generated.length > 0) {
-                                _log.event(`Generated ${generated.join(' and ')} for AI agents. Set \`agentRules: false\` in next.config to disable.`);
-                            }
-                        }
+                    logAgentFileSync(await (0, _appinfolog.syncAgentRulesForDev)(dir, initResult.agentRules !== false), (files)=>`Generated ${files} for AI agents. Set \`agentRules: false\` in next.config to disable.`, (files)=>`Removed agent rules from ${files} because \`agentRules\` is disabled.`);
+                    if (!_ciinfo.isCI) {
+                        const { traceGlobals } = require('../../trace/shared');
+                        const telemetry = traceGlobals.get('telemetry');
+                        const agentFeedbackConfigured = initResult.agentFeedback === true;
+                        const telemetryEnabled = (telemetry == null ? void 0 : telemetry.isEnabled) === true;
+                        logAgentFileSync(await (0, _appinfolog.syncAgentFeedbackForDev)(dir, agentFeedbackConfigured && telemetryEnabled), (files)=>`Generated agent feedback instructions in ${files}. Set \`experimental.agentFeedback: false\` in next.config to disable.`, (files)=>agentFeedbackConfigured ? `Removed agent feedback instructions from ${files} because Next.js Telemetry is disabled.` : `Removed agent feedback instructions from ${files} because \`experimental.agentFeedback\` is disabled.`);
                     }
                 }
                 handlersReady();
@@ -483,7 +467,7 @@ async function startServer(serverOptions) {
         });
         wp.on('remove', (removedPath)=>{
             if (dirWatchPaths.includes(removedPath)) {
-                _log.error(`The directory at "${removedPath}" was deleted.\n\n` + 'Deleting this directory while Next.js is running can lead to ' + 'undefined behavior. Restarting the server to recover...');
+                _log.error(`The directory at "${removedPath}" was deleted.\n\n` + 'Deleting this directory removes caches and will cause slower ' + 'performance.\n\n' + 'Deleting this directory while Next.js is running can lead to ' + 'undefined behavior. Restarting the server to recover...');
                 process.exit(_utils.RESTART_EXIT_CODE);
             }
         });
@@ -493,6 +477,10 @@ async function startServer(serverOptions) {
     };
 }
 if (process.env.NEXT_PRIVATE_WORKER && process.send) {
+    // Output is piped to the CLI to hold it while the upgrade menu is open.
+    if (process.env.NEXT_PRIVATE_PROMPT_OUTPUT === '1') {
+        (0, _utils.blockOnOutputWrites)();
+    }
     process.addListener('message', async (msg)=>{
         if (msg && typeof msg === 'object' && msg.nextWorkerOptions && process.send) {
             let enabledFeaturesFromParent = {};
@@ -536,5 +524,27 @@ if (process.env.NEXT_PRIVATE_WORKER && process.send) {
         nextWorkerReady: true
     });
 }
+/**
+ * Report which agent files a managed-block sync touched. Silent when the sync
+ * was a no-op so every `next dev` start doesn't mention the files.
+ */ function logAgentFileSync(result, generatedMessage, removedMessage) {
+    if (!result) return;
+    const generated = [];
+    const removed = [];
+    for (const [file, action] of [
+        [
+            'AGENTS.md',
+            result.agentsMd
+        ]
+    ]){
+        if (action === 'created' || action === 'updated') {
+            generated.push(file);
+        } else if (action === 'removed') {
+            removed.push(file);
+        }
+    }
+    if (generated.length > 0) _log.event(generatedMessage(generated.join(' and ')));
+    if (removed.length > 0) _log.event(removedMessage(removed.join(' and ')));
+}
 
 //# sourceMappingURL=start-server.js.map

package/app/node_modules/next/dist/server/lib/trace/constants.js

@@ -11,7 +11,10 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     AppRenderSpan: null,
     AppRouteRouteHandlersSpan: null,
+    AppRouteRouteModuleSpan: null,
     BaseServerSpan: null,
+    DevBundlerServiceSpan: null,
+    InstrumentationSpan: null,
     LoadComponentsSpan: null,
     LogSpanAllowList: null,
     MiddlewareSpan: null,
@@ -21,6 +24,7 @@ Object.defineProperty(exports, "__esModule", {
     NodeSpan: null,
     RenderSpan: null,
     ResolveMetadataSpan: null,
+    RouteModuleSpan: null,
     RouterSpan: null,
     StartServerSpan: null
 });
@@ -37,9 +41,18 @@ _export(exports, {
     AppRouteRouteHandlersSpan: function() {
         return AppRouteRouteHandlersSpan;
     },
+    AppRouteRouteModuleSpan: function() {
+        return AppRouteRouteModuleSpan;
+    },
     BaseServerSpan: function() {
         return BaseServerSpan;
     },
+    DevBundlerServiceSpan: function() {
+        return DevBundlerServiceSpan;
+    },
+    InstrumentationSpan: function() {
+        return InstrumentationSpan;
+    },
     LoadComponentsSpan: function() {
         return LoadComponentsSpan;
     },
@@ -67,6 +80,9 @@ _export(exports, {
     ResolveMetadataSpan: function() {
         return ResolveMetadataSpan;
     },
+    RouteModuleSpan: function() {
+        return RouteModuleSpan;
+    },
     RouterSpan: function() {
         return RouterSpan;
     },
@@ -92,8 +108,14 @@ var BaseServerSpan = /*#__PURE__*/ function(BaseServerSpan) {
 var LoadComponentsSpan = /*#__PURE__*/ function(LoadComponentsSpan) {
     LoadComponentsSpan["loadDefaultErrorComponents"] = "LoadComponents.loadDefaultErrorComponents";
     LoadComponentsSpan["loadComponents"] = "LoadComponents.loadComponents";
+    LoadComponentsSpan["loadRouteModule"] = "LoadComponents.loadRouteModule";
     return LoadComponentsSpan;
 }(LoadComponentsSpan || {});
+var InstrumentationSpan = /*#__PURE__*/ function(InstrumentationSpan) {
+    InstrumentationSpan["loadModule"] = "Instrumentation.loadModule";
+    InstrumentationSpan["register"] = "Instrumentation.register";
+    return InstrumentationSpan;
+}(InstrumentationSpan || {});
 var NextServerSpan = /*#__PURE__*/ function(NextServerSpan) {
     NextServerSpan["getRequestHandler"] = "NextServer.getRequestHandler";
     NextServerSpan["getRequestHandlerWithMetadata"] = "NextServer.getRequestHandlerWithMetadata";
@@ -160,6 +182,10 @@ var AppRenderSpan = /*#__PURE__*/ function(AppRenderSpan) {
     AppRenderSpan["instantInsightsRunValidation"] = "AppRender.instantInsights.runValidation";
     return AppRenderSpan;
 }(AppRenderSpan || {});
+var DevBundlerServiceSpan = /*#__PURE__*/ function(DevBundlerServiceSpan) {
+    DevBundlerServiceSpan["ensurePage"] = "DevBundlerService.ensurePage";
+    return DevBundlerServiceSpan;
+}(DevBundlerServiceSpan || {});
 var RouterSpan = /*#__PURE__*/ function(RouterSpan) {
     RouterSpan["executeRoute"] = "Router.executeRoute";
     return RouterSpan;
@@ -172,6 +198,15 @@ var AppRouteRouteHandlersSpan = /*#__PURE__*/ function(AppRouteRouteHandlersSpan
     AppRouteRouteHandlersSpan["runHandler"] = "AppRouteRouteHandlers.runHandler";
     return AppRouteRouteHandlersSpan;
 }(AppRouteRouteHandlersSpan || {});
+var AppRouteRouteModuleSpan = /*#__PURE__*/ function(AppRouteRouteModuleSpan) {
+    AppRouteRouteModuleSpan["loadUserland"] = "AppRouteRouteModule.loadUserland";
+    return AppRouteRouteModuleSpan;
+}(AppRouteRouteModuleSpan || {});
+var RouteModuleSpan = /*#__PURE__*/ function(RouteModuleSpan) {
+    RouteModuleSpan["prepare"] = "RouteModule.prepare";
+    RouteModuleSpan["loadManifests"] = "RouteModule.loadManifests";
+    return RouteModuleSpan;
+}(RouteModuleSpan || {});
 var ResolveMetadataSpan = /*#__PURE__*/ function(ResolveMetadataSpan) {
     ResolveMetadataSpan["generateMetadata"] = "ResolveMetadata.generateMetadata";
     ResolveMetadataSpan["generateViewport"] = "ResolveMetadata.generateViewport";
@@ -188,9 +223,14 @@ const NextVanillaSpanAllowlist = new Set([
     "Render.getStaticProps",
     "AppRender.fetch",
     "AppRender.getBodyResult",
+    "LoadComponents.loadRouteModule",
     "Render.renderDocument",
     "Node.runHandler",
     "AppRouteRouteHandlers.runHandler",
+    "AppRouteRouteModule.loadUserland",
+    "RouteModule.prepare",
+    "Instrumentation.loadModule",
+    "Instrumentation.register",
     "ResolveMetadata.generateMetadata",
     "ResolveMetadata.generateViewport",
     "NextNodeServer.createComponentTree",

package/app/node_modules/next/dist/server/lib/trace/request-insights-identity.js

@@ -24,10 +24,8 @@ const _asynclocalstorage = require("../../app-render/async-local-storage");
 // This storage covers the part of BaseServer request handling that runs before
 // App Render creates workAsyncStorage. Once available, workStore remains the
 // primary identity source for locally recorded spans.
-const REQUEST_INSIGHTS_IDENTITY_STORAGE_KEY = Symbol.for('@next/request-insights-identity-storage');
 function getRequestInsightsIdentityStorage() {
-    const globalStore = globalThis;
-    return globalStore[REQUEST_INSIGHTS_IDENTITY_STORAGE_KEY] ??= (0, _asynclocalstorage.createAsyncLocalStorage)();
+    return (0, _asynclocalstorage.getOrCreateGlobalAsyncLocalStorage)('request-insights-identity-storage');
 }
 function runWithRequestInsightsIdentity(identity, fn) {
     return getRequestInsightsIdentityStorage().run(identity, fn);

package/app/node_modules/next/dist/server/lib/trace/tracer.js

@@ -70,7 +70,7 @@ function isBubbledError(error) {
     if (typeof error !== 'object' || error === null) return false;
     return error instanceof BubbledError;
 }
-const closeSpanWithError = (span, error)=>{
+const closeSpanWithError = (span, error, endTime)=>{
     if (isBubbledError(error) && error.bubble) {
         span.setAttribute('next.bubble', true);
     } else {
@@ -83,7 +83,7 @@ const closeSpanWithError = (span, error)=>{
             message: error == null ? void 0 : error.message
         });
     }
-    span.end();
+    span.end(endTime);
 };
 /** we use this map to propagate attributes from nested spans to the top span */ const rootSpanAttributesStore = new Map();
 const rootSpanIdKey = api.createContextKey('next.rootSpanId');
@@ -103,7 +103,7 @@ class NextTracerImpl {
    * Since wrap / trace can be defined in any place prior to actual trace subscriber initialization,
    * This should be lazily evaluated.
    */ getTracerInstance() {
-        return trace.getTracer('next.js', '0.0.1');
+        return trace.getTracer('next.js', "16.4.1");
     }
     isOpenTelemetryEnabled() {
         var _tracerProvider_getDelegate_constructor, _tracerProvider_getDelegate;
@@ -239,13 +239,13 @@ class NextTracerImpl {
                     try {
                         return fn(span, (err)=>{
                             if (err) {
-                                closeSpanWithError(span, err);
+                                closeSpanWithError(span, err, options.endTime);
                             } else {
-                                span.end();
+                                span.end(options.endTime);
                             }
                         });
                     } catch (err) {
-                        closeSpanWithError(span, err);
+                        closeSpanWithError(span, err, options.endTime);
                         throw err;
                     } finally{
                         onCleanup();
@@ -256,21 +256,21 @@ class NextTracerImpl {
                     if ((0, _isthenable.isThenable)(result)) {
                         // If there's error make sure it throws
                         return result.then((res)=>{
-                            span.end();
+                            span.end(options.endTime);
                             // Need to pass down the promise result,
                             // it could be react stream response with error { error, stream }
                             return res;
                         }).catch((err)=>{
-                            closeSpanWithError(span, err);
+                            closeSpanWithError(span, err, options.endTime);
                             throw err;
                         }).finally(onCleanup);
                     } else {
-                        span.end();
+                        span.end(options.endTime);
                         onCleanup();
                     }
                     return result;
                 } catch (err) {
-                    closeSpanWithError(span, err);
+                    closeSpanWithError(span, err, options.endTime);
                     onCleanup();
                     throw err;
                 }

package/app/node_modules/next/dist/server/lib/utils.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     RESTART_EXIT_CODE: null,
+    blockOnOutputWrites: null,
     formatDebugAddress: null,
     formatNodeOptions: null,
     getFormattedNodeOptionsWithoutInspect: null,
@@ -28,6 +29,9 @@ _export(exports, {
     RESTART_EXIT_CODE: function() {
         return RESTART_EXIT_CODE;
     },
+    blockOnOutputWrites: function() {
+        return blockOnOutputWrites;
+    },
     formatDebugAddress: function() {
         return formatDebugAddress;
     },
@@ -78,12 +82,31 @@ function printAndExit(message, code = 1) {
     }
     return process.exit(code);
 }
+/**
+ * Node.js CLI flags that can be repeated. Node runs every occurrence of these
+ * flags, so they need to be preserved individually rather than collapsed into
+ * a single value keyed by option name.
+ * https://nodejs.org/api/cli.html#--requiremodule
+ * https://nodejs.org/api/cli.html#--importmodule
+ */ const REPEATABLE_OPTIONS = {
+    require: {
+        type: 'string',
+        multiple: true
+    },
+    import: {
+        type: 'string',
+        multiple: true
+    }
+};
 const parseNodeArgs = (args)=>{
-    const { values, tokens } = (0, _nodeutil.parseArgs)({
+    const parsed = (0, _nodeutil.parseArgs)({
         args,
         strict: false,
-        tokens: true
+        tokens: true,
+        options: REPEATABLE_OPTIONS
     });
+    const values = parsed.values;
+    const tokens = parsed.tokens;
     // For the `NODE_OPTIONS`, we support arguments with values without the `=`
     // sign. We need to parse them manually.
     let orphan = null;
@@ -109,12 +132,28 @@ const parseNodeArgs = (args)=>{
         if (!orphan) {
             continue;
         }
+        const name = orphan.name;
+        // If the option is repeatable, accumulate each occurrence instead of
+        // collapsing them into a single value.
+        if (name in REPEATABLE_OPTIONS) {
+            if (Array.isArray(values[name])) {
+                values[name].push(token.value);
+            } else if (typeof values[name] === 'string') {
+                values[name] = [
+                    values[name],
+                    token.value
+                ];
+            } else {
+                values[name] = token.value;
+            }
+            continue;
+        }
         // If the token is a positional one, and it has a value, so add it to the
         // values object. If it already exists, append it with a space.
-        if (orphan.name in values && typeof values[orphan.name] === 'string') {
-            values[orphan.name] += ` ${token.value}`;
+        if (name in values && typeof values[name] === 'string') {
+            values[name] += ` ${token.value}`;
         } else {
-            values[orphan.name] = token.value;
+            values[name] = token.value;
         }
     }
     return values;
@@ -129,11 +168,7 @@ const tokenizeArgs = (input)=>{
         if (char === '\\' && isInString) {
             // Ensure we don't have an escape character at the end.
             if (input.length === i + 1) {
-                throw Object.defineProperty(new Error('Invalid escape character at the end.'), "__NEXT_ERROR_CODE", {
-                    value: "E168",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('Invalid escape character at the end.');
             }
             // Skip the next character.
             char = input[++i];
@@ -153,11 +188,7 @@ const tokenizeArgs = (input)=>{
         }
     }
     if (isInString) {
-        throw Object.defineProperty(new Error('Unterminated string'), "__NEXT_ERROR_CODE", {
-            value: "E208",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error('Unterminated string');
     }
     return args;
 };
@@ -207,6 +238,16 @@ function formatArg(key, value) {
     if (value === true) {
         return `--${key}`;
     }
+    if (Array.isArray(value)) {
+        const formatted = [];
+        for (const item of value){
+            const formattedItem = formatArg(key, item);
+            if (formattedItem !== null) {
+                formatted.push(formattedItem);
+            }
+        }
+        return formatted.length > 0 ? formatted.join(' ') : null;
+    }
     if (value) {
         return `--${key}=${// Values with spaces need to be quoted. We use JSON.stringify to
         // also escape any nested quotes.
@@ -288,5 +329,15 @@ function getMaxOldSpaceSize() {
     if (!size || typeof size !== 'string') return;
     return parseInt(size, 10);
 }
+function blockOnOutputWrites() {
+    for (const stream of [
+        process.stdout,
+        process.stderr
+    ]){
+        var _stream__handle_setBlocking, _stream__handle;
+        ;
+        (_stream__handle = stream._handle) == null ? void 0 : (_stream__handle_setBlocking = _stream__handle.setBlocking) == null ? void 0 : _stream__handle_setBlocking.call(_stream__handle, true);
+    }
+}
 
 //# sourceMappingURL=utils.js.map