qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/build/index.js

@@ -86,7 +86,6 @@ const _formatmanifest = require("./manifests/formatter/format-manifest");
 const _builddiagnostics = require("../diagnostics/build-diagnostics");
 const _appinfolog = require("../server/lib/app-info-log");
 const _utils2 = require("../export/utils");
-const _buildcustomroute = require("../lib/build-custom-route");
 const _trace1 = require("../lib/memory/trace");
 const _encryptionutilsserver = require("../server/app-render/encryption-utils-server");
 const _uploadtrace = /*#__PURE__*/ _interop_require_default(require("../trace/upload-trace"));
@@ -95,7 +94,6 @@ const _fallback = require("../lib/fallback");
 const _renderingmode = require("./rendering-mode");
 const _invarianterror = require("../shared/lib/invariant-error");
 const _isbot = require("../shared/lib/router/utils/is-bot");
-const _buildprefetchsegmentdataroute = require("../server/lib/router-utils/build-prefetch-segment-data-route");
 const _turbopackbuild = require("./turbopack-build");
 const _utils3 = require("../shared/lib/turbopack/utils");
 const _inlinestaticenv = require("../lib/inline-static-env");
@@ -110,6 +108,9 @@ const _sortableroutes = require("../shared/lib/router/utils/sortable-routes");
 const _promises = require("fs/promises");
 const _routetypesutils = require("../server/lib/router-utils/route-types-utils");
 const _lockfile = require("./lockfile");
+const _buildprefetchsegmentdataroute = require("../server/lib/router-utils/build-prefetch-segment-data-route");
+const _generateroutesmanifest = require("./generate-routes-manifest");
+const _validateapppaths = require("./validate-app-paths");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -167,18 +168,6 @@ function _interop_require_wildcard(obj, nodeInterop) {
     _constants.NEXT_CACHE_REVALIDATED_TAGS_HEADER,
     _constants.NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER
 ];
-function pageToRoute(page, sourcePage) {
-    const routeRegex = (0, _routeregex.getNamedRouteRegex)(page, {
-        prefixRouteKeys: true
-    });
-    return {
-        sourcePage,
-        page,
-        regex: (0, _loadcustomroutes.normalizeRouteRegex)(routeRegex.re.source),
-        routeKeys: routeRegex.routeKeys,
-        namedRegex: routeRegex.namedRegex
-    };
-}
 function getCacheDir(distDir) {
     const cacheDir = _path.default.join(distDir, 'cache');
     if (_ciinfo.isCI && !_ciinfo.hasNextSupport) {
@@ -216,10 +205,15 @@ async function writeClientSsgManifest(prerenderManifest, { buildId, distDir, loc
     await writeFileUtf8(_path.default.join(distDir, _constants1.CLIENT_STATIC_FILES_PATH, buildId, '_ssgManifest.js'), clientSsgManifestContent);
 }
 async function writeFunctionsConfigManifest(distDir, manifest) {
-    await writeManifest(_path.default.join(distDir, _constants1.SERVER_DIRECTORY, _constants1.FUNCTIONS_CONFIG_MANIFEST), manifest);
+    let sortedManifest = {
+        version: manifest.version,
+        functions: Object.fromEntries(Object.entries(manifest.functions).sort(([a], [b])=>a.localeCompare(b)))
+    };
+    await writeManifest(_path.default.join(distDir, _constants1.SERVER_DIRECTORY, _constants1.FUNCTIONS_CONFIG_MANIFEST), sortedManifest);
 }
 async function writeRequiredServerFilesManifest(distDir, requiredServerFiles) {
-    await writeManifest(_path.default.join(distDir, _constants1.SERVER_FILES_MANIFEST), requiredServerFiles);
+    await writeManifest(_path.default.join(distDir, _constants1.SERVER_FILES_MANIFEST + '.json'), requiredServerFiles);
+    await writeFileUtf8(_path.default.join(distDir, _constants1.SERVER_FILES_MANIFEST + '.js'), `self.__SERVER_FILES_MANIFEST=${(0, _formatmanifest.formatManifest)(requiredServerFiles)}`);
 }
 async function writeImagesManifest(distDir, config) {
     var _config_images, _config_images1;
@@ -267,7 +261,7 @@ async function writeStandaloneDirectory(nextBuildSpan, distDir, pageKeys, denorm
         requiredServerFiles.appDir, distDir, pageKeys.pages, denormalizedAppPages, outputFileTracingRoot, requiredServerFiles.config, middlewareManifest, hasNodeMiddleware, hasInstrumentationHook, staticPages);
         for (const file of [
             ...requiredServerFiles.files,
-            _path.default.join(requiredServerFiles.config.distDir, _constants1.SERVER_FILES_MANIFEST),
+            _path.default.join(requiredServerFiles.config.distDir, _constants1.SERVER_FILES_MANIFEST + '.json'),
             ...loadedEnvFiles.reduce((acc, envFile)=>{
                 if ([
                     '.env',
@@ -373,11 +367,13 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
     _buildcontext.NextBuildContext.isCompileMode = isCompileMode;
     _buildcontext.NextBuildContext.analyze = experimentalAnalyze;
     const buildStartTime = Date.now();
+    let appType;
     let loadedConfig;
+    let staticWorker;
     try {
         const nextBuildSpan = (0, _trace.trace)('next-build', undefined, {
             buildMode: experimentalBuildMode,
-            version: "16.0.10"
+            version: "16.1.1"
         });
         _buildcontext.NextBuildContext.nextBuildSpan = nextBuildSpan;
         _buildcontext.NextBuildContext.dir = dir;
@@ -436,7 +432,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
             // when using compile mode static env isn't inlined so we
             // need to populate in normal runtime env
             if (isCompileMode || isGenerateMode) {
-                (0, _staticenv.populateStaticEnv)(config);
+                (0, _staticenv.populateStaticEnv)(config, config.deploymentId);
             }
             const customRoutes = await nextBuildSpan.traceChild('load-custom-routes').traceAsyncFn(()=>(0, _loadcustomroutes.default)(config));
             const { headers, rewrites, redirects } = customRoutes;
@@ -484,6 +480,13 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
             (0, _trace.setGlobal)('telemetry', telemetry);
             const publicDir = _path.default.join(dir, 'public');
             const { pagesDir, appDir } = (0, _findpagesdir.findPagesDir)(dir);
+            if (pagesDir && appDir) {
+                appType = 'hybrid';
+            } else if (pagesDir) {
+                appType = 'pages';
+            } else if (appDir) {
+                appType = 'app';
+            }
             if (!appDirOnly && !pagesDir) {
                 appDirOnly = true;
             }
@@ -537,7 +540,11 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 telemetry,
                 nextBuildSpan,
                 config,
-                cacheDir
+                cacheDir,
+                debugBuildPaths: debugBuildAppPaths !== undefined || debugBuildPagePaths !== undefined ? {
+                    app: debugBuildAppPaths,
+                    pages: debugBuildPagePaths
+                } : undefined
             };
             if (appDir && 'exportPathMap' in config) {
                 const errorMessage = 'The "exportPathMap" configuration cannot be used with the "app" directory. Please use generateStaticParams() instead.';
@@ -704,6 +711,11 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 }
             }
             const appPaths = Array.from(appPageKeys);
+            // Validate that the app paths are valid. This is currently duplicating
+            // the logic from packages/next/src/shared/lib/router/utils/sorted-routes.ts
+            // but is instead specifically focused on code that can be shared
+            // eventually with the development code.
+            (0, _validateapppaths.validateAppPaths)(appPaths);
             // Interception routes are modelled as beforeFiles rewrites
             rewrites.beforeFiles.push(...(0, _generateinterceptionroutesrewrites.generateInterceptionRoutesRewrites)(appPaths, config.basePath));
             _buildcontext.NextBuildContext.rewrites = rewrites;
@@ -832,73 +844,17 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
             const isAuthInterruptsEnabled = Boolean(config.experimental.authInterrupts);
             const isAppPPREnabled = (0, _ppr.checkIsAppPPREnabled)(config.experimental.ppr);
             const routesManifestPath = _path.default.join(distDir, _constants1.ROUTES_MANIFEST);
-            const dynamicRoutes = [];
-            /**
-       * A map of all the pages to their sourcePage value. This is only used for
-       * routes that have PPR enabled and clientSegmentEnabled is true.
-       */ const sourcePages = new Map();
-            const routesManifest = nextBuildSpan.traceChild('generate-routes-manifest').traceFn(()=>{
-                const sortedRoutes = (0, _sortableroutes.sortPages)([
-                    ...pageKeys.pages,
-                    ...pageKeys.app ?? []
-                ]);
-                const staticRoutes = [];
-                for (const route of sortedRoutes){
-                    if ((0, _utils.isDynamicRoute)(route)) {
-                        dynamicRoutes.push(pageToRoute(route, // This property is only relevant when PPR is enabled.
-                        undefined));
-                    } else if (!(0, _utils1.isReservedPage)(route) || // don't consider /api reserved here
-                    route.match(/^\/(api(\/|$))/)) {
-                        staticRoutes.push(pageToRoute(route));
-                    }
-                }
-                return {
-                    version: 3,
-                    pages404: true,
-                    caseSensitive: !!config.experimental.caseSensitiveRoutes,
-                    basePath: config.basePath,
-                    redirects: redirects.map((r)=>(0, _buildcustomroute.buildCustomRoute)('redirect', r, restrictedRedirectPaths)),
-                    headers: headers.map((r)=>(0, _buildcustomroute.buildCustomRoute)('header', r)),
-                    rewrites: {
-                        beforeFiles: rewrites.beforeFiles.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r)),
-                        afterFiles: rewrites.afterFiles.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r)),
-                        fallback: rewrites.fallback.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r))
-                    },
-                    dynamicRoutes,
-                    staticRoutes,
-                    dataRoutes: [],
-                    i18n: config.i18n || undefined,
-                    rsc: {
-                        header: _approuterheaders.RSC_HEADER,
-                        // This vary header is used as a default. It is technically re-assigned in `base-server`,
-                        // and may include an additional Vary option for `Next-URL`.
-                        varyHeader: `${_approuterheaders.RSC_HEADER}, ${_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER}, ${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}, ${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}`,
-                        prefetchHeader: _approuterheaders.NEXT_ROUTER_PREFETCH_HEADER,
-                        didPostponeHeader: _approuterheaders.NEXT_DID_POSTPONE_HEADER,
-                        contentTypeHeader: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
-                        suffix: _constants.RSC_SUFFIX,
-                        prefetchSuffix: _constants.RSC_PREFETCH_SUFFIX,
-                        prefetchSegmentHeader: _approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
-                        prefetchSegmentSuffix: _constants.RSC_SEGMENT_SUFFIX,
-                        prefetchSegmentDirSuffix: _constants.RSC_SEGMENTS_DIR_SUFFIX,
-                        clientParamParsing: config.cacheComponents ?? false,
-                        clientParamParsingOrigins: config.experimental.clientParamParsingOrigins,
-                        dynamicRSCPrerender: isAppPPREnabled && config.cacheComponents === true
-                    },
-                    rewriteHeaders: {
-                        pathHeader: _approuterheaders.NEXT_REWRITTEN_PATH_HEADER,
-                        queryHeader: _approuterheaders.NEXT_REWRITTEN_QUERY_HEADER
-                    },
-                    skipProxyUrlNormalize: config.skipProxyUrlNormalize,
-                    ppr: isAppPPREnabled ? {
-                        chain: {
-                            headers: {
-                                [_constants.NEXT_RESUME_HEADER]: '1'
-                            }
-                        }
-                    } : undefined
-                };
-            });
+            // Generate the routes manifest using the extracted helper
+            const { routesManifest, dynamicRoutes, sourcePages } = nextBuildSpan.traceChild('generate-routes-manifest').traceFn(()=>(0, _generateroutesmanifest.generateRoutesManifest)({
+                    appType,
+                    pageKeys,
+                    config,
+                    redirects,
+                    headers,
+                    rewrites,
+                    restrictedRedirectPaths,
+                    isAppPPREnabled
+                }));
             // For pages directory, we run type checking after route collection but before build.
             if (!appDir && !isCompileMode) {
                 await (0, _typecheck.startTypeChecking)(typeCheckingOptions);
@@ -915,7 +871,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
             // Files outside of the distDir can be "type": "module"
             await writeFileUtf8(_path.default.join(distDir, 'package.json'), '{"type": "commonjs"}');
             // These are written to distDir, so they need to come after creating and cleaning distDr.
-            await (0, _builddiagnostics.recordFrameworkVersion)("16.0.10");
+            await (0, _builddiagnostics.recordFrameworkVersion)("16.1.1");
             await (0, _builddiagnostics.updateBuildDiagnostics)({
                 buildStage: 'start'
             });
@@ -1061,6 +1017,98 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 await (0, _typecheck.startTypeChecking)(typeCheckingOptions);
                 (0, _trace1.traceMemoryUsage)('Finished type checking', nextBuildSpan);
             }
+            const requiredServerFilesManifest = await nextBuildSpan.traceChild('generate-required-server-files').traceAsyncFn(async ()=>{
+                let runtimeConfig = (0, _configshared.getNextConfigRuntime)(config);
+                const normalizedCacheHandlers = {};
+                for (const [key, value] of Object.entries(runtimeConfig.cacheHandlers || {})){
+                    if (key && value) {
+                        normalizedCacheHandlers[key] = _path.default.relative(distDir, value);
+                    }
+                }
+                const serverFilesManifest = {
+                    version: 1,
+                    config: {
+                        ...runtimeConfig,
+                        ..._ciinfo.hasNextSupport ? {
+                            compress: false
+                        } : {},
+                        cacheHandler: runtimeConfig.cacheHandler ? _path.default.relative(distDir, runtimeConfig.cacheHandler) : runtimeConfig.cacheHandler,
+                        cacheHandlers: normalizedCacheHandlers,
+                        experimental: {
+                            ...runtimeConfig.experimental,
+                            trustHostHeader: _ciinfo.hasNextSupport,
+                            isExperimentalCompile: isCompileMode
+                        }
+                    },
+                    appDir: dir,
+                    relativeAppDir: _path.default.relative(outputFileTracingRoot, dir),
+                    files: [
+                        _constants1.ROUTES_MANIFEST,
+                        _path.default.relative(distDir, pagesManifestPath),
+                        _constants1.BUILD_MANIFEST,
+                        _constants1.PRERENDER_MANIFEST,
+                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.FUNCTIONS_CONFIG_MANIFEST),
+                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_MANIFEST),
+                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_BUILD_MANIFEST + '.js'),
+                        ...bundler !== _bundler.Bundler.Turbopack ? [
+                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_REACT_LOADABLE_MANIFEST + '.js'),
+                            _constants1.REACT_LOADABLE_MANIFEST
+                        ] : [],
+                        ...appDir ? [
+                            ...config.experimental.sri ? [
+                                _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SUBRESOURCE_INTEGRITY_MANIFEST + '.js'),
+                                _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SUBRESOURCE_INTEGRITY_MANIFEST + '.json')
+                            ] : [],
+                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.APP_PATHS_MANIFEST),
+                            _path.default.join(_constants1.APP_PATH_ROUTES_MANIFEST),
+                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SERVER_REFERENCE_MANIFEST + '.js'),
+                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SERVER_REFERENCE_MANIFEST + '.json')
+                        ] : [],
+                        ...pagesDir && bundler !== _bundler.Bundler.Turbopack ? [
+                            _constants1.DYNAMIC_CSS_MANIFEST + '.json',
+                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.DYNAMIC_CSS_MANIFEST + '.js')
+                        ] : [],
+                        _constants1.BUILD_ID_FILE,
+                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.NEXT_FONT_MANIFEST + '.js'),
+                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.NEXT_FONT_MANIFEST + '.json'),
+                        _constants1.SERVER_FILES_MANIFEST + '.json'
+                    ].filter(_nonnullable.nonNullable).map((file)=>_path.default.join(config.distDir, file)),
+                    ignore: []
+                };
+                if (hasInstrumentationHook) {
+                    serverFilesManifest.files.push(_path.default.join(config.distDir, _constants1.SERVER_DIRECTORY, `${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`));
+                    // If there are edge routes, append the edge instrumentation hook
+                    // Turbopack generates this chunk with a hashed name and references it in middleware-manifest.
+                    let edgeInstrumentationHook = _path.default.join(config.distDir, _constants1.SERVER_DIRECTORY, `edge-${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`);
+                    if (bundler !== _bundler.Bundler.Turbopack && (0, _fs.existsSync)(_path.default.join(dir, edgeInstrumentationHook))) {
+                        serverFilesManifest.files.push(edgeInstrumentationHook);
+                    }
+                }
+                if (config.experimental.optimizeCss) {
+                    const globOrig = require('next/dist/compiled/glob');
+                    const cssFilePaths = await new Promise((resolve, reject)=>{
+                        globOrig('**/*.css', {
+                            cwd: _path.default.join(distDir, 'static')
+                        }, (err, files)=>{
+                            if (err) {
+                                return reject(err);
+                            }
+                            resolve(files);
+                        });
+                    });
+                    serverFilesManifest.files.push(...cssFilePaths.map((filePath)=>_path.default.join(config.distDir, 'static', filePath)));
+                }
+                // Under standalone mode, we need to ensure that the cache entry debug
+                // handler is copied so that it can be used in the test. This is required
+                // for the turbopack test to run as it's more strict about the build
+                // directories. This is only used for testing and is not used in
+                // production.
+                if (process.env.__NEXT_TEST_MODE && process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) {
+                    serverFilesManifest.files.push(_path.default.relative(dir, _path.default.isAbsolute(process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) ? process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS : _path.default.join(dir, process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS)));
+                }
+                return serverFilesManifest;
+            });
+            await writeRequiredServerFilesManifest(distDir, requiredServerFilesManifest);
             const numberOfWorkers = getNumberOfWorkers(config);
             const collectingPageDataStart = process.hrtime();
             const postCompileSpinner = (0, _spinner.default)(`Collecting page data using ${numberOfWorkers} worker${numberOfWorkers > 1 ? 's' : ''}`);
@@ -1092,7 +1140,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 await writeManifest(_path.default.join(distDir, _constants1.APP_PATH_ROUTES_MANIFEST), appPathRoutes);
             }
             process.env.NEXT_PHASE = _constants1.PHASE_PRODUCTION_BUILD;
-            const worker = createStaticWorker(config, {
+            staticWorker = createStaticWorker(config, {
                 numberOfWorkers,
                 debuggerPortOffset: -1
             });
@@ -1115,7 +1163,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 const { configFileName } = config;
                 const sriEnabled = Boolean((_config_experimental_sri = config.experimental.sri) == null ? void 0 : _config_experimental_sri.algorithm);
                 const nonStaticErrorPageSpan = staticCheckSpan.traceChild('check-static-error-page');
-                const errorPageHasCustomGetInitialProps = nonStaticErrorPageSpan.traceAsyncFn(async ()=>hasCustomErrorPage && await worker.hasCustomGetInitialProps({
+                const errorPageHasCustomGetInitialProps = nonStaticErrorPageSpan.traceAsyncFn(async ()=>hasCustomErrorPage && await staticWorker.hasCustomGetInitialProps({
                         page: '/_error',
                         distDir,
                         checkingApp: false,
@@ -1123,7 +1171,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                     }));
                 const errorPageStaticResult = nonStaticErrorPageSpan.traceAsyncFn(async ()=>{
                     var _config_i18n, _config_i18n1;
-                    return hasCustomErrorPage && worker.isPageStatic({
+                    return hasCustomErrorPage && staticWorker.isPageStatic({
                         dir,
                         page: '/_error',
                         distDir,
@@ -1142,13 +1190,13 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                     });
                 });
                 const appPageToCheck = '/_app';
-                const customAppGetInitialPropsPromise = hasUserPagesRoutes ? worker.hasCustomGetInitialProps({
+                const customAppGetInitialPropsPromise = hasUserPagesRoutes ? staticWorker.hasCustomGetInitialProps({
                     page: appPageToCheck,
                     distDir,
                     checkingApp: true,
                     sriEnabled
                 }) : Promise.resolve(false);
-                const namedExportsPromise = hasUserPagesRoutes ? worker.getDefinedNamedExports({
+                const namedExportsPromise = hasUserPagesRoutes ? staticWorker.getDefinedNamedExports({
                     page: appPageToCheck,
                     distDir,
                     sriEnabled
@@ -1263,7 +1311,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                                     let isPageStaticSpan = checkPageSpan.traceChild('is-page-static');
                                     let workerResult = await isPageStaticSpan.traceAsyncFn(()=>{
                                         var _config_i18n, _config_i18n1;
-                                        return worker.isPageStatic({
+                                        return staticWorker.isPageStatic({
                                             dir,
                                             page,
                                             originalAppPath,
@@ -1455,77 +1503,6 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 console.warn((0, _picocolors.bold)((0, _picocolors.yellow)(`Warning: `)) + (0, _picocolors.yellow)(`You have opted-out of Automatic Static Optimization due to \`getInitialProps\` in \`pages/_app\`. This does not opt-out pages with \`getStaticProps\``));
                 console.warn('Read more: https://nextjs.org/docs/messages/opt-out-auto-static-optimization\n');
             }
-            const { cacheHandler } = config;
-            const instrumentationHookEntryFiles = [];
-            if (hasInstrumentationHook) {
-                instrumentationHookEntryFiles.push(_path.default.join(_constants1.SERVER_DIRECTORY, `${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`));
-                // If there's edge routes, append the edge instrumentation hook
-                // Turbopack generates this chunk with a hashed name and references it in middleware-manifest.
-                if (bundler !== _bundler.Bundler.Turbopack && (edgeRuntimeAppCount || edgeRuntimePagesCount)) {
-                    instrumentationHookEntryFiles.push(_path.default.join(_constants1.SERVER_DIRECTORY, `edge-${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`));
-                }
-            }
-            const requiredServerFilesManifest = nextBuildSpan.traceChild('generate-required-server-files').traceFn(()=>{
-                const normalizedCacheHandlers = {};
-                for (const [key, value] of Object.entries(config.cacheHandlers || {})){
-                    if (key && value) {
-                        normalizedCacheHandlers[key] = _path.default.relative(distDir, value);
-                    }
-                }
-                const serverFilesManifest = {
-                    version: 1,
-                    config: {
-                        ...config,
-                        configFile: undefined,
-                        ..._ciinfo.hasNextSupport ? {
-                            compress: false
-                        } : {},
-                        cacheHandler: cacheHandler ? _path.default.relative(distDir, cacheHandler) : config.cacheHandler,
-                        cacheHandlers: normalizedCacheHandlers,
-                        experimental: {
-                            ...config.experimental,
-                            trustHostHeader: _ciinfo.hasNextSupport,
-                            isExperimentalCompile: isCompileMode
-                        }
-                    },
-                    appDir: dir,
-                    relativeAppDir: _path.default.relative(outputFileTracingRoot, dir),
-                    files: [
-                        _constants1.ROUTES_MANIFEST,
-                        _path.default.relative(distDir, pagesManifestPath),
-                        _constants1.BUILD_MANIFEST,
-                        _constants1.PRERENDER_MANIFEST,
-                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.FUNCTIONS_CONFIG_MANIFEST),
-                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_MANIFEST),
-                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_BUILD_MANIFEST + '.js'),
-                        ...bundler !== _bundler.Bundler.Turbopack ? [
-                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_REACT_LOADABLE_MANIFEST + '.js'),
-                            _constants1.REACT_LOADABLE_MANIFEST
-                        ] : [],
-                        ...appDir ? [
-                            ...config.experimental.sri ? [
-                                _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SUBRESOURCE_INTEGRITY_MANIFEST + '.js'),
-                                _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SUBRESOURCE_INTEGRITY_MANIFEST + '.json')
-                            ] : [],
-                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.APP_PATHS_MANIFEST),
-                            _path.default.join(_constants1.APP_PATH_ROUTES_MANIFEST),
-                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SERVER_REFERENCE_MANIFEST + '.js'),
-                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.SERVER_REFERENCE_MANIFEST + '.json')
-                        ] : [],
-                        ...pagesDir && bundler !== _bundler.Bundler.Turbopack ? [
-                            _constants1.DYNAMIC_CSS_MANIFEST + '.json',
-                            _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.DYNAMIC_CSS_MANIFEST + '.js')
-                        ] : [],
-                        _constants1.BUILD_ID_FILE,
-                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.NEXT_FONT_MANIFEST + '.js'),
-                        _path.default.join(_constants1.SERVER_DIRECTORY, _constants1.NEXT_FONT_MANIFEST + '.json'),
-                        _constants1.SERVER_FILES_MANIFEST,
-                        ...instrumentationHookEntryFiles
-                    ].filter(_nonnullable.nonNullable).map((file)=>_path.default.join(config.distDir, file)),
-                    ignore: []
-                };
-                return serverFilesManifest;
-            });
             const middlewareFile = (0, _normalizepathsep.normalizePathSep)(proxyFilePath || middlewareFilePath || '');
             let hasNodeMiddleware = false;
             if (middlewareFile) {
@@ -1609,28 +1586,6 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 throw err;
             }
             await (0, _writebuildid.writeBuildId)(distDir, buildId);
-            if (config.experimental.optimizeCss) {
-                const globOrig = require('next/dist/compiled/glob');
-                const cssFilePaths = await new Promise((resolve, reject)=>{
-                    globOrig('**/*.css', {
-                        cwd: _path.default.join(distDir, 'static')
-                    }, (err, files)=>{
-                        if (err) {
-                            return reject(err);
-                        }
-                        resolve(files);
-                    });
-                });
-                requiredServerFilesManifest.files.push(...cssFilePaths.map((filePath)=>_path.default.join(config.distDir, 'static', filePath)));
-            }
-            // Under standalone mode, we need to ensure that the cache entry debug
-            // handler is copied so that it can be used in the test. This is required
-            // for the turbopack test to run as it's more strict about the build
-            // directories. This is only used for testing and is not used in
-            // production.
-            if (process.env.__NEXT_TEST_MODE && process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) {
-                requiredServerFilesManifest.files.push(_path.default.relative(dir, _path.default.isAbsolute(process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) ? process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS : _path.default.join(dir, process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS)));
-            }
             const features = [
                 {
                     featureName: 'experimental/cacheComponents',
@@ -1663,7 +1618,6 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                     payload: feature
                 };
             }));
-            await writeRequiredServerFilesManifest(distDir, requiredServerFilesManifest);
             // we don't need to inline for turbopack build as
             // it will handle it's own caching separate of compile
             if (isGenerateMode && bundler !== _bundler.Bundler.Turbopack) {
@@ -1857,7 +1811,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                         statusMessage: `Generating static pages using ${numberOfWorkers} worker${numberOfWorkers > 1 ? 's' : ''}`,
                         numWorkers: numberOfWorkers,
                         appDirOnly
-                    }, nextBuildSpan);
+                    }, nextBuildSpan, staticWorker);
                     // If there was no result, there's nothing more to do.
                     if (!exportResult) return;
                     const getFallbackMode = (route)=>{
@@ -2026,19 +1980,6 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                                 } else {
                                     dataRoute = _path.default.posix.join(`${normalizedRoute}${_constants.RSC_SUFFIX}`);
                                 }
-                                let prefetchDataRoute = null;
-                                // While we may only write the `.rsc` when the route does not
-                                // have PPR enabled, we still want to generate the route when
-                                // deployed so it doesn't 404. If the app has PPR enabled, we
-                                // should add this key.
-                                if (!isAppRouteHandler && isAppPPREnabled && // Don't add a prefetch data route if we have
-                                // cacheComponents enabled. This is
-                                // because we don't actually use the prefetch data route in
-                                // this case. This only applies if we have PPR enabled for
-                                // this route.
-                                !(config.cacheComponents && isRoutePPREnabled)) {
-                                    prefetchDataRoute = _path.default.posix.join(`${normalizedRoute}${_constants.RSC_PREFETCH_SUFFIX}`);
-                                }
                                 const meta = (0, _utils1.collectMeta)(metadata);
                                 const status = route.pathname === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE ? 404 : meta.status;
                                 prerenderManifest.routes[route.pathname] = {
@@ -2051,7 +1992,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                                     initialExpireSeconds: cacheControl.expire,
                                     srcRoute: page,
                                     dataRoute,
-                                    prefetchDataRoute,
+                                    prefetchDataRoute: undefined,
                                     allowHeader: ALLOWED_HEADERS
                                 };
                             } else {
@@ -2111,20 +2052,12 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                                 let prefetchDataRoute = null;
                                 let dynamicRoute = routesManifest.dynamicRoutes.find((r)=>r.page === route.pathname);
                                 if (!isAppRouteHandler && isAppPPREnabled) {
-                                    if (// Don't add a prefetch data route if we have
-                                    // cacheComponents enabled. This is
-                                    // because we don't actually use the prefetch data route in
-                                    // this case. This only applies if we have PPR enabled for
-                                    // this route.
-                                    !config.cacheComponents || !isRoutePPREnabled) {
-                                        prefetchDataRoute = _path.default.posix.join(`${normalizedRoute}${_constants.RSC_PREFETCH_SUFFIX}`);
-                                    }
                                     // If the dynamic route wasn't found, then we need to create
                                     // it. This ensures that for each fallback shell there's an
                                     // entry in the app routes manifest which enables routing for
                                     // this fallback shell.
                                     if (!dynamicRoute) {
-                                        dynamicRoute = pageToRoute(route.pathname, page);
+                                        dynamicRoute = (0, _utils1.pageToRoute)(route.pathname, page);
                                         sourcePages.set(route.pathname, page);
                                         // This route is not for the internal router, but instead
                                         // for external routers.
@@ -2166,14 +2099,6 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                                         builtSegmentDataRoute.destination = builtSegmentDataRoute.destination.replace('/__PAGE__.segment.rsc', '$segment');
                                         dynamicRoute.prefetchSegmentDataRoutes ??= [];
                                         dynamicRoute.prefetchSegmentDataRoutes.push(builtSegmentDataRoute);
-                                    } else if (route.fallbackRootParams && route.fallbackRootParams.length > 0) {
-                                        dynamicRoute.hasFallbackRootParams = true;
-                                        dynamicRoute.prefetchSegmentDataRoutes = [
-                                            (0, _buildprefetchsegmentdataroute.buildInversePrefetchSegmentDataRoute)(dynamicRoute.page, // We use the special segment path of `/_tree` because it's
-                                            // the first one sent by the client router so it's the only
-                                            // one we need to rewrite to the regular prefetch RSC route.
-                                            '/_tree')
-                                        ];
                                     }
                                 }
                                 pageInfos.set(route.pathname, {
@@ -2456,8 +2381,13 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 buildTracesStart = process.hrtime();
                 buildTracesSpinner = (0, _spinner.default)('Collecting build traces');
             }
-            // ensure the worker is not left hanging
-            worker.end();
+            // When output: export we want to end the worker later as it's still used for writeFullyStaticExport
+            if (config.output !== 'export') {
+                // ensure the worker is not left hanging
+                staticWorker == null ? void 0 : staticWorker.end();
+                staticWorker = undefined // Reset staticWorker to make sure it does not end in `finally`
+                ;
+            }
             const analysisEnd = process.hrtime(analysisBegin);
             telemetry.record((0, _events.eventBuildOptimize)(pagesPaths, {
                 durationInSeconds: analysisEnd[0],
@@ -2593,6 +2523,11 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 _log.info(`Build ran with "compile" mode, to finalize the build run either "generate" or "generate-env" mode as well`);
             }
             if (config.output === 'export') {
+                // TODO: When writeFullyStaticExport doesn't fail when staticWorker is passed moved this after writeFullyStaticExport.
+                // End the worker here when it's output: export.
+                staticWorker.end();
+                staticWorker = undefined // Reset staticWorker to make sure it does not end in `finally`
+                ;
                 await nextBuildSpan.traceChild('output-export-full-static-export').traceAsyncFn(async ()=>{
                     await writeFullyStaticExport(config, dir, enabledDirectories, configOutDir, nextBuildSpan, appDirOnly);
                 });
@@ -2611,7 +2546,7 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                         configOutDir: _path.default.join(dir, configOutDir),
                         staticPages,
                         serverPropsPages,
-                        nextVersion: "16.0.10",
+                        nextVersion: "16.1.1",
                         tracingRoot: outputFileTracingRoot,
                         hasNodeMiddleware,
                         hasInstrumentationHook,
@@ -2657,6 +2592,16 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
                 }));
             await nextBuildSpan.traceChild('telemetry-flush').traceAsyncFn(()=>telemetry.flush());
             await shutdownPromise;
+            if (_buildcontext.NextBuildContext.analyze) {
+                await (0, _promises.cp)(_path.default.join(__dirname, '../bundle-analyzer'), _path.default.join(dir, '.next/diagnostics/analyze'), {
+                    recursive: true
+                });
+                await (0, _promises.mkdir)(_path.default.join(dir, '.next/diagnostics/analyze/data'), {
+                    recursive: true
+                });
+                // Write an index of routes for the route picker
+                await (0, _promises.writeFile)(_path.default.join(dir, '.next/diagnostics/analyze/data/routes.json'), JSON.stringify(routesManifest.dynamicRoutes.map((r)=>r.page).concat(routesManifest.staticRoutes.map((r)=>r.page)), null, 2));
+            }
         });
     } catch (e) {
         const telemetry = _shared.traceGlobals.get('telemetry');
@@ -2669,6 +2614,10 @@ async function build(dir, experimentalAnalyze = false, reactProductionProfiling
         }
         throw e;
     } finally{
+        // @ts-expect-error Existence of staticWorker is checked here intentionally.
+        if (staticWorker) {
+            staticWorker.end();
+        }
         // Ensure we wait for lockfile patching if present
         await _swc.lockfilePatchPromise.cur;
         // Flush telemetry before finishing (waits for async operations like setTimeout in debug mode)

qalita/_frontend/node_modules/next/dist/build/output/log.js

@@ -85,17 +85,14 @@ function prefixedLog(prefixType, ...message) {
         // Ensure if there's ANSI escape codes it's concatenated into one string.
         // Chrome DevTool can only handle color if it's in one string.
         if (message.length === 1 && typeof message[0] === 'string') {
-            console[consoleMethod](' ' + prefix + ' ' + message[0]);
+            console[consoleMethod](prefix + ' ' + message[0]);
         } else {
-            console[consoleMethod](' ' + prefix, ...message);
+            console[consoleMethod](prefix, ...message);
         }
     }
 }
-function bootstrap(...message) {
-    // logging format: ' <prefix> <message>'
-    // e.g. ' ✓ Compiled successfully'
-    // Add spaces to align with the indent of other logs
-    console.log('   ' + message.join(' '));
+function bootstrap(message) {
+    console.log(message);
 }
 function wait(...message) {
     prefixedLog('wait', ...message);