@semiont/frontend 0.3.2 → 0.3.4

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

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     generateLinkTypesFile: null,
     generateRouteTypesFile: null,
-    generateValidatorFile: null
+    generateRouteTypesFileStrict: null,
+    generateValidatorFile: null,
+    generateValidatorFileStrict: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -20,8 +22,14 @@ _export(exports, {
     generateRouteTypesFile: function() {
         return generateRouteTypesFile;
     },
+    generateRouteTypesFileStrict: function() {
+        return generateRouteTypesFileStrict;
+    },
     generateValidatorFile: function() {
         return generateValidatorFile;
+    },
+    generateValidatorFileStrict: function() {
+        return generateValidatorFileStrict;
     }
 });
 const _isdynamic = require("../../../shared/lib/router/utils/is-dynamic");
@@ -472,7 +480,7 @@ function generateValidatorFile(routesManifest) {
   default: (req: any, res: any) => ReturnType<NextApiHandler>
   config?: {
     api?: {
-      bodyParser?: boolean | { sizeLimit?: string }
+      bodyParser?: boolean | { sizeLimit?: number | string }
       responseLimit?: string | number | boolean
       externalResolver?: boolean
     }
@@ -526,6 +534,162 @@ ${pagesRouterPageValidations}
 
 ${pagesApiRouteValidations}
 
+${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)=>{
+            // 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;
+            return `// Validate ${filePath}
+{
+  const handler = {} as typeof import(${JSON.stringify(importPath.replace(/\.tsx?$/, '.js'))})
+  handler satisfies ${typeWithRoute}
+}`;
+        }).join('\n\n');
+    // Use direct mappings from the manifest
+    // Generate validations for different route types
+    const appPageValidations = generateValidations(Array.from(routesManifest.appPagePaths).sort(), 'AppPageConfig', routesManifest.filePathToRoute);
+    const appRouteHandlerValidations = generateValidations(Array.from(routesManifest.appRouteHandlers).sort(), 'RouteHandlerConfig', routesManifest.filePathToRoute);
+    const pagesRouterPageValidations = generateValidations(Array.from(routesManifest.pagesRouterPagePaths).sort(), 'PagesPageConfig');
+    const pagesApiRouteValidations = generateValidations(Array.from(routesManifest.pageApiRoutes).sort(), 'ApiRouteConfig');
+    const layoutValidations = generateValidations(Array.from(routesManifest.layoutPaths).sort(), 'LayoutConfig', routesManifest.filePathToRoute);
+    const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
+    // Build type definitions based on what's actually used
+    let typeDefinitions = '';
+    if (appPageValidations) {
+        typeDefinitions += `type AppPageConfig<Route extends AppRoutes = AppRoutes> = {
+  default: React.JSXElementConstructor<PageProps<Route>>
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: PageProps<Route>,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: PageProps<Route>,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`;
+    }
+    if (pagesRouterPageValidations) {
+        typeDefinitions += `type PagesPageConfig = {
+  default: React.ComponentType<any> | ((props: any) => React.ReactNode | Promise<React.ReactNode> | never | void)
+  getStaticProps?: (context: any) => Promise<any> | any
+  getStaticPaths?: (context: any) => Promise<any> | any
+  getServerSideProps?: (context: any) => Promise<any> | any
+  getInitialProps?: (context: any) => Promise<any> | any
+  /**
+   * Segment configuration for legacy Pages Router pages.
+   * Validated at build-time by parsePagesSegmentConfig.
+   */
+  config?: {
+    maxDuration?: number
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    regions?: string[]
+  }
+}
+
+`;
+    }
+    if (layoutValidations) {
+        typeDefinitions += `type LayoutConfig<Route extends LayoutRoutes = LayoutRoutes> = {
+  default: React.ComponentType<LayoutProps<Route>> | ((props: LayoutProps<Route>) => React.ReactNode | Promise<React.ReactNode> | never | void | Promise<void>)
+  generateStaticParams?: (props: { params: ParamMap[Route] }) => Promise<any[]> | any[]
+  generateMetadata?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingMetadata
+  ) => Promise<any> | any
+  generateViewport?: (
+    props: { params: Promise<ParamMap[Route]> } & any,
+    parent: ResolvingViewport
+  ) => Promise<any> | any
+  metadata?: any
+  viewport?: any
+}
+
+`;
+    }
+    if (appRouteHandlerValidations) {
+        typeDefinitions += `type RouteHandlerConfig<Route extends AppRouteHandlerRoutes = AppRouteHandlerRoutes> = {
+  GET?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  POST?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PUT?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  PATCH?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  DELETE?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  HEAD?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+  OPTIONS?: (request: NextRequest, context: { params: Promise<ParamMap[Route]> }) => Promise<Response | void> | Response | void
+}
+
+`;
+    }
+    if (pagesApiRouteValidations) {
+        typeDefinitions += `type ApiRouteConfig = {
+  default: (req: any, res: any) => ReturnType<NextApiHandler>
+  config?: {
+    api?: {
+      bodyParser?: boolean | { sizeLimit?: number | string }
+      responseLimit?: string | number | boolean
+      externalResolver?: boolean
+    }
+    runtime?: 'edge' | 'experimental-edge' | 'nodejs' | string // necessary unless config is exported as const
+    maxDuration?: number
+  }
+}
+
+`;
+    }
+    // Build import statement based on what's actually needed
+    const routeImports = [];
+    // Only import AppRoutes if there are app pages
+    if (appPageValidations) {
+        routeImports.push('AppRoutes');
+    }
+    // Only import LayoutRoutes if there are layouts
+    if (layoutValidations) {
+        routeImports.push('LayoutRoutes');
+    }
+    // Only import ParamMap if there are routes that use it
+    if (appPageValidations || layoutValidations || appRouteHandlerValidations) {
+        routeImports.push('ParamMap');
+    }
+    if (hasAppRouteHandlers) {
+        routeImports.push('AppRouteHandlerRoutes');
+    }
+    const routeImportStatement = routeImports.length > 0 ? `import type { ${routeImports.join(', ')} } from "./routes.js"` : '';
+    const nextRequestImport = hasAppRouteHandlers ? "import type { NextRequest } from 'next/server.js'\n" : '';
+    // Conditionally import types from next/types, merged into a single statement
+    const nextTypes = [];
+    if (pagesApiRouteValidations) {
+        nextTypes.push('NextApiHandler');
+    }
+    if (appPageValidations || layoutValidations) {
+        nextTypes.push('ResolvingMetadata', 'ResolvingViewport');
+    }
+    const nextTypesImport = nextTypes.length > 0 ? `import type { ${nextTypes.join(', ')} } from "next/types.js"\n` : '';
+    return `// This file is generated automatically by Next.js with experimental.strictRouteTypes
+// Do not edit this file manually
+// This file validates that all pages and layouts export the correct types
+
+${routeImportStatement}
+${nextTypesImport}${nextRequestImport}
+${typeDefinitions}
+${appPageValidations}
+
+${appRouteHandlerValidations}
+
+${pagesRouterPageValidations}
+
+${pagesApiRouteValidations}
+
 ${layoutValidations}
 `;
 }
@@ -575,6 +739,87 @@ ${layoutSlotMap}
 
 ${exportStatement}
 
+declare global {
+  /**
+   * Props for Next.js App Router page components
+   * @example
+   * \`\`\`tsx
+   * export default function Page(props: PageProps<'/blog/[slug]'>) {
+   *   const { slug } = await props.params
+   *   return <div>Blog post: {slug}</div>
+   * }
+   * \`\`\`
+   */
+  interface PageProps<AppRoute extends AppRoutes> {
+    params: Promise<ParamMap[AppRoute]>
+    searchParams: Promise<Record<string, string | string[] | undefined>>
+  }
+
+  /**
+   * Props for Next.js App Router layout components
+   * @example
+   * \`\`\`tsx
+   * export default function Layout(props: LayoutProps<'/dashboard'>) {
+   *   return <div>{props.children}</div>
+   * }
+   * \`\`\`
+   */
+  type LayoutProps<LayoutRoute extends LayoutRoutes> = {
+    params: Promise<ParamMap[LayoutRoute]>
+    children: React.ReactNode
+  } & {
+    [K in LayoutSlotMap[LayoutRoute]]: React.ReactNode
+  }${routeContextInterface}
+}
+`;
+}
+function generateRouteTypesFileStrict(routesManifest) {
+    const routeTypes = generateRouteTypes(routesManifest);
+    const paramTypes = generateParamTypes(routesManifest);
+    const layoutSlotMap = generateLayoutSlotMap(routesManifest);
+    const hasAppRouteHandlers = Object.keys(routesManifest.appRouteHandlerRoutes).length > 0;
+    // Build export statement based on what's actually generated
+    const routeExports = [
+        'AppRoutes',
+        'PageProps',
+        'PageRoutes',
+        'LayoutRoutes',
+        'RedirectRoutes',
+        'RewriteRoutes',
+        'ParamMap'
+    ];
+    if (hasAppRouteHandlers) {
+        routeExports.push('AppRouteHandlerRoutes');
+    }
+    const exportStatement = `export type { ${routeExports.join(', ')} }`;
+    const routeContextInterface = hasAppRouteHandlers ? `
+
+  /**
+   * Context for Next.js App Router route handlers
+   * @example
+   * \`\`\`tsx
+   * export async function GET(request: NextRequest, context: RouteContext<'/api/users/[id]'>) {
+   *   const { id } = await context.params
+   *   return Response.json({ id })
+   * }
+   * \`\`\`
+   */
+  interface RouteContext<AppRouteHandlerRoute extends AppRouteHandlerRoutes> {
+    params: Promise<ParamMap[AppRouteHandlerRoute]>
+  }` : '';
+    return `// This file is generated automatically by Next.js with experimental.strictRouteTypes
+// Do not edit this file manually
+
+${routeTypes}
+
+${paramTypes}
+
+export type ParamsOf<Route extends Routes> = ParamMap[Route]
+
+${layoutSlotMap}
+
+${exportStatement}
+
 declare global {
   /**
    * Props for Next.js App Router page components

package/standalone/node_modules/next/dist/server/lib/server-ipc/utils.js

@@ -67,7 +67,8 @@ const INTERNAL_HEADERS = [
     'x-middleware-override-headers',
     'x-middleware-next',
     'x-now-route-matches',
-    'x-matched-path'
+    'x-matched-path',
+    'x-next-resume-state-length'
 ];
 const filterInternalHeaders = (headers)=>{
     for(const header in headers){

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

@@ -44,6 +44,7 @@ const _turbopackwarning = require("../../lib/turbopack-warning");
 const _trace = require("../../trace");
 const _isipv6 = require("./is-ipv6");
 const _asynccallbackset = require("./async-callback-set");
+const _durationtostring = require("../../build/duration-to-string");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -90,9 +91,6 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-if (performance.getEntriesByName('next-start').length === 0) {
-    performance.mark('next-start');
-}
 const debug = (0, _debug.default)('next:start-server');
 let startServerSpan;
 /**
@@ -161,7 +159,7 @@ let startServerSpan;
     pidPromise.finally(()=>clearTimeout(timeoutId));
     return pidPromise;
 }
-async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server, hostname, minimalMode, keepAliveTimeout, experimentalHttpsServer, quiet }) {
+async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server, hostname, minimalMode, keepAliveTimeout, experimentalHttpsServer, serverFastRefresh, quiet }) {
     return (0, _routerserver.initialize)({
         dir,
         port,
@@ -172,14 +170,15 @@ async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server
         server,
         keepAliveTimeout,
         experimentalHttpsServer,
+        serverFastRefresh,
         startServerSpan,
         quiet
     });
 }
 async function startServer(serverOptions) {
-    const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate } = serverOptions;
+    const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate, serverFastRefresh } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"16.1.6"})`;
+    process.title = `next-server (v${"16.2.0"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{
@@ -273,7 +272,7 @@ async function startServer(serverOptions) {
         }
     });
     let cleanupListeners = isDev ? new _asynccallbackset.AsyncCallbackSet() : undefined;
-    await new Promise((resolve)=>{
+    const distDir = await new Promise((resolve)=>{
         server.on('listening', async ()=>{
             const addr = server.address();
             const actualHostname = (0, _formathostname.formatHostname)(typeof addr === 'object' ? (addr == null ? void 0 : addr.address) || hostname || 'localhost' : addr);
@@ -300,32 +299,27 @@ async function startServer(serverOptions) {
             if (selfSignedCertificate) {
                 process.env.__NEXT_EXPERIMENTAL_HTTPS = '1';
             }
-            // Only load env and config in dev to for logging purposes
-            let envInfo;
-            let experimentalFeatures;
-            let cacheComponents;
+            // Get env info first (fast, doesn't require config)
+            const envInfo = isDev ? (0, _appinfolog.getEnvInfo)(dir) : undefined;
+            // Log basic startup info immediately (before loading config)
+            (0, _appinfolog.logStartInfo)({
+                networkUrl,
+                appUrl,
+                envInfo,
+                logBundler: isDev
+            });
+            // Calculate and log "Ready in X" before loading config
+            // so it reflects actual framework startup time.
+            // NEXT_PRIVATE_START_TIME is set by bin/next.ts or cli/next-start.ts.
+            const startTime = parseInt(process.env.NEXT_PRIVATE_START_TIME || '0', 10);
+            const endTime = Date.now();
+            const startServerProcessDurationMs = startTime ? endTime - startTime : 0;
+            const formattedStartDuration = (0, _durationtostring.durationToString)(startServerProcessDurationMs / 1000);
+            _log.event(`Ready in ${formattedStartDuration}`);
             try {
-                if (isDev) {
-                    const startServerInfo = await (0, _appinfolog.getStartServerInfo)({
-                        dir,
-                        dev: isDev
-                    });
-                    envInfo = startServerInfo.envInfo;
-                    cacheComponents = startServerInfo.cacheComponents;
-                    experimentalFeatures = startServerInfo.experimentalFeatures;
-                }
-                (0, _appinfolog.logStartInfo)({
-                    networkUrl,
-                    appUrl,
-                    envInfo,
-                    experimentalFeatures,
-                    cacheComponents,
-                    logBundler: isDev
-                });
-                _log.event(`Starting...`);
                 let cleanupStarted = false;
                 let closeUpgraded = null;
-                const cleanup = ()=>{
+                const cleanup = (signal)=>{
                     if (cleanupStarted) {
                         // We can get duplicate signals, e.g. when `ctrl+c` is used in an
                         // interactive shell (i.e. bash, zsh), the shell will recursively
@@ -353,6 +347,8 @@ async function startServer(serverOptions) {
                             nextServer == null ? void 0 : nextServer.close().catch(console.error),
                             cleanupListeners == null ? void 0 : cleanupListeners.runAll().catch(console.error)
                         ]);
+                        // Flush any remaining traces to the trace file on shutdown
+                        await (0, _trace.flushAllTraces)();
                         // Flush telemetry if this is a dev server
                         if (isDev) {
                             try {
@@ -369,7 +365,22 @@ async function startServer(serverOptions) {
                             }
                         }
                         debug('start-server process cleanup finished');
-                        process.exit(0);
+                        // Exit with signal-based exit code (128 + signal number) so that
+                        // Node.js treats this as a signal termination, not a normal exit.
+                        // This avoids waiting for the debugger to disconnect.
+                        switch(signal){
+                            case 'SIGINT':
+                                process.exit(130);
+                                break;
+                            case 'SIGTERM':
+                                process.exit(143);
+                                break;
+                            default:
+                                // Make sure all handled signals have explicit exit codes.
+                                // This is just a fallback to guard against unsound types.
+                                signal;
+                                process.exit(128);
+                        }
                     })();
                 };
                 // Make sure commands gracefully respect termination signals (e.g. from Docker)
@@ -378,6 +389,7 @@ async function startServer(serverOptions) {
                     process.on('SIGINT', cleanup);
                     process.on('SIGTERM', cleanup);
                 }
+                // Now load config via getRequestHandlers (single loadConfig call)
                 const initResult = await getRequestHandlers({
                     dir,
                     port,
@@ -387,29 +399,34 @@ async function startServer(serverOptions) {
                     hostname,
                     minimalMode,
                     keepAliveTimeout,
-                    experimentalHttpsServer: !!selfSignedCertificate
+                    experimentalHttpsServer: !!selfSignedCertificate,
+                    serverFastRefresh
                 });
                 requestHandler = initResult.requestHandler;
                 upgradeHandler = initResult.upgradeHandler;
                 nextServer = initResult.server;
                 closeUpgraded = initResult.closeUpgraded;
-                const startServerProcessDuration = performance.mark('next-start-end') && performance.measure('next-start-duration', 'next-start', 'next-start-end').duration;
+                // Log experimental features after config is loaded
+                if (isDev) {
+                    (0, _appinfolog.logExperimentalInfo)({
+                        experimentalFeatures: initResult.experimentalFeatures,
+                        cacheComponents: initResult.cacheComponents
+                    });
+                }
                 handlersReady();
-                const formatDurationText = startServerProcessDuration > 2000 ? `${Math.round(startServerProcessDuration / 100) / 10}s` : `${Math.round(startServerProcessDuration)}ms`;
-                _log.event(`Ready in ${formatDurationText}`);
                 if (process.env.TURBOPACK && isDev) {
                     await (0, _turbopackwarning.validateTurboNextConfig)({
                         dir: serverOptions.dir,
                         configPhase: _constants.PHASE_DEVELOPMENT_SERVER
                     });
                 }
+                resolve(initResult.distDir);
             } catch (err) {
                 // fatal error if we can't setup
                 handlersError();
                 console.error(err);
                 process.exit(1);
             }
-            resolve();
         });
         server.listen(port, hostname);
     });
@@ -430,25 +447,42 @@ async function startServer(serverOptions) {
             process.exit(_utils.RESTART_EXIT_CODE);
         });
     }
+    return {
+        distDir
+    };
 }
 if (process.env.NEXT_PRIVATE_WORKER && process.send) {
     process.addListener('message', async (msg)=>{
         if (msg && typeof msg === 'object' && msg.nextWorkerOptions && process.send) {
+            let enabledFeaturesFromParent = {};
+            if (process.env.NEXT_PRIVATE_ENABLED_FEATURES) {
+                const parsed = JSON.parse(process.env.NEXT_PRIVATE_ENABLED_FEATURES);
+                enabledFeaturesFromParent = Object.fromEntries(Object.entries(parsed).map(([key, value])=>[
+                        `feature.${key}`,
+                        value
+                    ]));
+            }
             startServerSpan = (0, _trace.trace)('start-dev-server', undefined, {
                 cpus: String(_os.default.cpus().length),
                 platform: _os.default.platform(),
                 'memory.freeMem': String(_os.default.freemem()),
                 'memory.totalMem': String(_os.default.totalmem()),
-                'memory.heapSizeLimit': String(_v8.default.getHeapStatistics().heap_size_limit)
+                'memory.heapSizeLimit': String(_v8.default.getHeapStatistics().heap_size_limit),
+                ...enabledFeaturesFromParent
+            });
+            (0, _trace.initializeTraceState)({
+                ...(0, _trace.exportTraceState)(),
+                defaultParentSpanId: startServerSpan.getId()
             });
-            await startServerSpan.traceAsyncFn(()=>startServer(msg.nextWorkerOptions));
+            const result = await startServerSpan.traceAsyncFn(()=>startServer(msg.nextWorkerOptions));
             const memoryUsage = process.memoryUsage();
             startServerSpan.setAttribute('memory.rss', String(memoryUsage.rss));
             startServerSpan.setAttribute('memory.heapTotal', String(memoryUsage.heapTotal));
             startServerSpan.setAttribute('memory.heapUsed', String(memoryUsage.heapUsed));
             process.send({
                 nextServerReady: true,
-                port: process.env.PORT
+                port: process.env.PORT,
+                distDir: result.distDir
             });
         }
     });

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

@@ -109,8 +109,18 @@ class NextTracerImpl {
     getActiveScopeSpan() {
         return trace.getSpan(context == null ? void 0 : context.active());
     }
-    withPropagatedContext(carrier, fn, getter) {
+    withPropagatedContext(carrier, fn, getter, force = false) {
         const activeContext = context.active();
+        if (force) {
+            const remoteContext = propagation.extract(ROOT_CONTEXT, carrier, getter);
+            if (trace.getSpanContext(remoteContext)) {
+                return context.with(remoteContext, fn);
+            }
+            // Preserve the current active span while still merging any extracted
+            // baggage/context values from the carrier.
+            const mergedContext = propagation.extract(activeContext, carrier, getter);
+            return context.with(mergedContext, fn);
+        }
         if (trace.getSpanContext(activeContext)) {
             // Active span is already set, too late to propagate.
             return fn();

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

@@ -185,18 +185,47 @@ const getParsedDebugAddress = (address)=>{
         port: parseInt(address, 10)
     };
 };
+/**
+ * Node.js CLI flags that are not allowed in NODE_OPTIONS and must be
+ * passed as direct CLI arguments via execArgv.
+ * This set is the difference between all Node.js CLI flags and the ones **not**
+ * allowed in NODE_OPTIONS, as listed in the Node.js documentation:
+ * https://nodejs.org/api/cli.html#node_optionsoptions
+ *
+ * It is not exhaustive since not all options make sense for Next.js (e.g. --test)
+ */ const EXEC_ARGV_ONLY_OPTIONS = new Set([
+    'experimental-network-inspection',
+    'experimental-storage-inspection',
+    'experimental-worker-inspection',
+    'experimental-inspector-network-resource'
+]);
+function formatArg(key, value) {
+    if (value === true) {
+        return `--${key}`;
+    }
+    if (value) {
+        return `--${key}=${// Values with spaces need to be quoted. We use JSON.stringify to
+        // also escape any nested quotes.
+        value.includes(' ') && !value.startsWith('"') ? JSON.stringify(value) : value}`;
+    }
+    return null;
+}
 function formatNodeOptions(args) {
-    return Object.entries(args).map(([key, value])=>{
-        if (value === true) {
-            return `--${key}`;
-        }
-        if (value) {
-            return `--${key}=${// Values with spaces need to be quoted. We use JSON.stringify to
-            // also escape any nested quotes.
-            value.includes(' ') && !value.startsWith('"') ? JSON.stringify(value) : value}`;
+    const nodeOptionsParts = [];
+    const execArgv = [];
+    for (const [key, value] of Object.entries(args)){
+        const formatted = formatArg(key, value);
+        if (formatted === null) continue;
+        if (EXEC_ARGV_ONLY_OPTIONS.has(key)) {
+            execArgv.push(formatted);
+        } else {
+            nodeOptionsParts.push(formatted);
         }
-        return null;
-    }).filter((arg)=>arg !== null).join(' ');
+    }
+    return {
+        nodeOptions: nodeOptionsParts.join(' '),
+        execArgv
+    };
 }
 function getParsedNodeOptions() {
     const args = [
@@ -219,7 +248,7 @@ function getParsedNodeOptionsWithoutInspect() {
 function getFormattedNodeOptionsWithoutInspect() {
     const args = getParsedNodeOptionsWithoutInspect();
     if (Object.keys(args).length === 0) return '';
-    return formatNodeOptions(args);
+    return formatNodeOptions(args).nodeOptions;
 }
 function parseValidPositiveInteger(value) {
     const parsedValue = parseInt(value, 10);

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

@@ -135,7 +135,9 @@ needsManifestsForLegacyReasons }) {
         const App = (0, _interopdefault.interopDefault)(AppMod);
         const { getServerSideProps, getStaticProps, getStaticPaths, routeModule } = ComponentMod;
         return {
+            // @ts-expect-error this is indeed `{} || AppType` and not always `AppType`
             App,
+            // @ts-expect-error this is indeed `{} || DocumentType` and not always `DocumentType`
             Document,
             Component,
             buildManifest,