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

qalita/_frontend/node_modules/next/dist/build/type-check.js

@@ -67,7 +67,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
  * Since it is impossible to pass a function from main thread to a worker,
  * instead of running "next/lib/typescript/runTypeCheck" in a worker,
  * we will run entire "next/lib/verify-typescript-setup" in a worker instead.
- */ function verifyTypeScriptSetup(dir, distDir, intentDirs, typeCheckPreflight, tsconfigPath, disableStaticImages, cacheDir, enableWorkerThreads, hasAppDir, hasPagesDir, isolatedDevBuild) {
+ */ function verifyTypeScriptSetup(dir, distDir, typeCheckPreflight, tsconfigPath, disableStaticImages, cacheDir, enableWorkerThreads, hasAppDir, hasPagesDir, isolatedDevBuild, appDir, pagesDir, debugBuildPaths) {
     const typeCheckWorker = new _worker.Worker(require.resolve('../lib/verify-typescript-setup'), {
         exposedMethods: [
             'verifyTypeScriptSetup'
@@ -81,14 +81,16 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return typeCheckWorker.verifyTypeScriptSetup({
         dir,
         distDir,
-        intentDirs,
         typeCheckPreflight,
         tsconfigPath,
         disableStaticImages,
         cacheDir,
         hasAppDir,
         hasPagesDir,
-        isolatedDevBuild
+        isolatedDevBuild,
+        appDir,
+        pagesDir,
+        debugBuildPaths
     }).then((result)=>{
         typeCheckWorker.end();
         return result;
@@ -98,7 +100,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
         process.exit(1);
     });
 }
-async function startTypeChecking({ cacheDir, config, dir, nextBuildSpan, pagesDir, telemetry, appDir }) {
+async function startTypeChecking({ cacheDir, config, dir, nextBuildSpan, pagesDir, telemetry, appDir, debugBuildPaths }) {
     const ignoreTypeScriptErrors = Boolean(config.typescript.ignoreBuildErrors);
     if (ignoreTypeScriptErrors) {
         _log.info('Skipping validation of types');
@@ -113,10 +115,7 @@ async function startTypeChecking({ cacheDir, config, dir, nextBuildSpan, pagesDi
     }
     const typeCheckAndLintStart = process.hrtime();
     try {
-        const [verifyResult, typeCheckEnd] = await nextBuildSpan.traceChild('run-typescript').traceAsyncFn(()=>verifyTypeScriptSetup(dir, config.distDir, [
-                pagesDir,
-                appDir
-            ].filter(Boolean), !ignoreTypeScriptErrors, config.typescript.tsconfigPath, config.images.disableStaticImages, cacheDir, config.experimental.workerThreads, !!appDir, !!pagesDir, config.experimental.isolatedDevBuild).then((resolved)=>{
+        const [verifyResult, typeCheckEnd] = await nextBuildSpan.traceChild('run-typescript').traceAsyncFn(()=>verifyTypeScriptSetup(dir, config.distDir, !ignoreTypeScriptErrors, config.typescript.tsconfigPath, config.images.disableStaticImages, cacheDir, config.experimental.workerThreads, !!appDir, !!pagesDir, config.experimental.isolatedDevBuild, appDir, pagesDir, debugBuildPaths).then((resolved)=>{
                 const checkEnd = process.hrtime(typeCheckAndLintStart);
                 return [
                     resolved,

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

@@ -28,6 +28,7 @@ Object.defineProperty(exports, "__esModule", {
     isWebpackBundledLayer: null,
     isWebpackClientOnlyLayer: null,
     isWebpackDefaultLayer: null,
+    pageToRoute: null,
     printBuildErrors: null,
     printCustomRoutes: null,
     printTreeView: null,
@@ -117,6 +118,9 @@ _export(exports, {
     isWebpackDefaultLayer: function() {
         return isWebpackDefaultLayer;
     },
+    pageToRoute: function() {
+        return pageToRoute;
+    },
     printBuildErrors: function() {
         return printBuildErrors;
     },
@@ -137,6 +141,7 @@ _export(exports, {
     }
 });
 const _ppr = require("../server/lib/experimental/ppr");
+const _loadcustomroutes = require("../lib/load-custom-routes");
 const _constants = require("../lib/constants");
 require("../server/require-hook");
 require("../server/node-polyfill-crypto");
@@ -167,6 +172,8 @@ const _app = require("./static-paths/app");
 const _pages = require("./static-paths/pages");
 const _format = require("./output/format");
 const _utils = require("../shared/lib/turbopack/utils");
+const _routeregex = require("../shared/lib/router/utils/route-regex");
+const _app1 = require("../shared/lib/router/routes/app");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -666,6 +673,7 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
         const Comp = Component;
         let isRoutePPREnabled = false;
         if (pageType === 'app') {
+            // @ts-expect-error pageType is app, so we can assume AppPageModule | AppRouteModule
             const ComponentMod = componentsResult.ComponentMod;
             let segments;
             try {
@@ -696,14 +704,16 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             if (appConfig.dynamic === 'force-dynamic' && !isRoutePPREnabled) {
                 appConfig.revalidate = 0;
             }
+            const route = (0, _app1.parseAppRoute)(page, true);
             // If the page is dynamic and we're not in edge runtime, then we need to
             // build the static paths. The edge runtime doesn't support static
             // paths.
-            if ((0, _isdynamic.isDynamicRoute)(page) && !pathIsEdgeRuntime) {
+            if (route.dynamicSegments.length > 0 && !pathIsEdgeRuntime) {
                 ;
                 ({ prerenderedRoutes, fallbackMode: prerenderFallbackMode } = await (0, _app.buildAppStaticPaths)({
                     dir,
                     page,
+                    route,
                     cacheComponents,
                     authInterrupts,
                     segments,
@@ -858,11 +868,14 @@ async function hasCustomGetInitialProps({ page, distDir, checkingApp, sriEnabled
     });
     let mod = ComponentMod;
     if (checkingApp) {
+        // @ts-expect-error very dynamic code
         mod = await mod._app || mod.default || mod;
     } else {
+        // @ts-expect-error very dynamic code
         mod = mod.default || mod;
     }
     mod = await mod;
+    // @ts-expect-error very dynamic code
     return mod.getInitialProps !== mod.origGetInitialProps;
 }
 async function getDefinedNamedExports({ page, distDir, sriEnabled }) {
@@ -989,9 +1002,25 @@ async function copyTracedFiles(dir, distDir, pageKeys, appPageKeys, tracingRoot,
                 if (symlink) {
                     try {
                         await _fs.promises.symlink(symlink, fileOutputPath);
-                    } catch (e) {
-                        if (e.code !== 'EEXIST') {
-                            throw e;
+                    } catch (err) {
+                        // Windows doesn't support creating symlinks without elevated privileges, unless
+                        // "Developer Mode" is turned on. If we failed to crate a symlink due to EPERM, try
+                        // creating a junction point instead.
+                        //
+                        // Ideally we'd just preserve the input file type (junction point or symlink), but
+                        // there's no API in node.js to differentiate between a junction point and a symlink,
+                        // so we just try making a symlink first. Symlinks are preferred because they support
+                        // relative paths and non-directory (file) targets.
+                        if (process.platform === 'win32' && err.code === 'EPERM' && _path.default.isAbsolute(symlink)) {
+                            try {
+                                await _fs.promises.symlink(symlink, fileOutputPath, 'junction');
+                            } catch (junctionErr) {
+                                if (junctionErr.code !== 'EEXIST') {
+                                    throw junctionErr;
+                                }
+                            }
+                        } else if (err.code !== 'EEXIST') {
+                            throw err;
                         }
                     }
                 } else {
@@ -1216,5 +1245,17 @@ const RSPACK_DEFAULT_LAYERS_REGEX = new RegExp(`^(|${[
     _constants.WEBPACK_LAYERS.pagesDirEdge,
     _constants.WEBPACK_LAYERS.pagesDirNode
 ].join('|')})$`);
+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
+    };
+}
 
 //# sourceMappingURL=utils.js.map

qalita/_frontend/node_modules/next/dist/build/validate-app-paths.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateAppPaths", {
+    enumerable: true,
+    get: function() {
+        return validateAppPaths;
+    }
+});
+const _getsegmentparam = require("../shared/lib/router/utils/get-segment-param");
+const _app = require("../shared/lib/router/routes/app");
+/**
+ * Validates segment parameters for common syntax errors.
+ * Based on validation logic from sorted-routes.ts
+ */ function validateSegmentParam(param, pathname) {
+    // Check for empty parameter names
+    if (param.paramName.length === 0) {
+        throw Object.defineProperty(new Error(`Parameter names cannot be empty in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E922",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for three-dot character (…) instead of ...
+    if (param.paramName.includes('…')) {
+        throw Object.defineProperty(new Error(`Detected a three-dot character ('…') in parameter "${param.paramName}" in route "${pathname}". Did you mean ('...')?`), "__NEXT_ERROR_CODE", {
+            value: "E921",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for optional non-catch-all segments (not yet supported)
+    if (param.paramType !== 'optional-catchall' && param.paramName.startsWith('[') && param.paramName.endsWith(']')) {
+        throw Object.defineProperty(new Error(`Optional route parameters are not yet supported ("[${param.paramName}]") in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E926",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for extra brackets
+    if (param.paramName.startsWith('[') || param.paramName.endsWith(']')) {
+        throw Object.defineProperty(new Error(`Segment names may not start or end with extra brackets ('${param.paramName}') in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E916",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // Check for erroneous periods
+    if (param.paramName.startsWith('.')) {
+        throw Object.defineProperty(new Error(`Segment names may not start with erroneous periods ('${param.paramName}') in route "${pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E920",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+/**
+ * Validates a Route object for internal consistency.
+ * Checks for duplicate slugs, invalid catch-all placement, and other route errors.
+ * For interception routes, validates both the intercepting and intercepted routes separately.
+ * Returns the validated segment parameters.
+ */ function validateAppRoute(route) {
+    // For interception routes, validate the intercepting and intercepted routes separately
+    // This allows the same parameter name to appear in both parts
+    if ((0, _app.isInterceptionAppRoute)(route)) {
+        validateAppRoute(route.interceptingRoute);
+        validateAppRoute(route.interceptedRoute);
+        return;
+    }
+    // Then validate semantic constraints (duplicates, normalization, positioning)
+    const slugNames = new Set();
+    const normalizedSegments = new Set();
+    let hasCatchAll = false;
+    let hasOptionalCatchAllInPath = false;
+    let catchAllPosition = -1;
+    for(let i = 0; i < route.segments.length; i++){
+        const segment = route.segments[i];
+        // Type narrowing - only process dynamic segments
+        if (segment.type === 'dynamic') {
+            // First, validate syntax
+            validateSegmentParam(segment.param, route.pathname);
+            const properties = (0, _getsegmentparam.getParamProperties)(segment.param.paramType);
+            if (properties.repeat) {
+                if (properties.optional) {
+                    hasOptionalCatchAllInPath = true;
+                } else {
+                    hasCatchAll = true;
+                }
+                catchAllPosition = i;
+            }
+            // Check to see if the parameter name is already in use.
+            if (slugNames.has(segment.param.paramName)) {
+                throw Object.defineProperty(new Error(`You cannot have the same slug name "${segment.param.paramName}" repeat within a single dynamic path in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                    value: "E914",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            // Normalize parameter name for comparison by removing all non-word
+            // characters.
+            const normalizedSegment = segment.param.paramName.replace(/\W/g, '');
+            if (normalizedSegments.has(normalizedSegment)) {
+                const existing = Array.from(slugNames).find((s)=>{
+                    return s.replace(/\W/g, '') === normalizedSegment;
+                });
+                throw Object.defineProperty(new Error(`You cannot have the slug names "${existing}" and "${segment.param.paramName}" differ only by non-word symbols within a single dynamic path in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                    value: "E919",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            slugNames.add(segment.param.paramName);
+            normalizedSegments.add(normalizedSegment);
+        }
+        // Check if catch-all is not at the end
+        if (hasCatchAll && i > catchAllPosition) {
+            throw Object.defineProperty(new Error(`Catch-all must be the last part of the URL in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                value: "E918",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (hasOptionalCatchAllInPath && i > catchAllPosition) {
+            throw Object.defineProperty(new Error(`Optional catch-all must be the last part of the URL in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+                value: "E913",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    // Check for both required and optional catch-all
+    if (hasCatchAll && hasOptionalCatchAllInPath) {
+        throw Object.defineProperty(new Error(`You cannot use both a required and optional catch-all route at the same level in route "${route.pathname}".`), "__NEXT_ERROR_CODE", {
+            value: "E911",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+/**
+ * Validates a single path for internal consistency and returns its segment parameters.
+ */ function parseAndValidateAppPath(path) {
+    // Fast parse the route information. We're expecting this to be a normalized
+    // route, so we pass `true` to the `parseAppRoute` function.
+    const route = (0, _app.parseAppRoute)(path, true);
+    // Slow walk the data from the route in order to validate it.
+    validateAppRoute(route);
+    return route;
+}
+/**
+ * Normalizes segments by replacing dynamic segment names with placeholders.
+ * This allows us to compare routes for structural equivalence.
+ * Preserves interception markers so that routes with different markers are not considered ambiguous.
+ *
+ * Examples:
+ * - [slug] -> [*]
+ * - [modalSlug] -> [*]
+ * - [...slug] -> [...*]
+ * - [[...slug]] -> [[...*]]
+ * - (..)test -> (..)test
+ * - (..)[slug] -> (..)[*]
+ */ function normalizeSegments(segments) {
+    return '/' + segments.map((segment)=>{
+        if (segment.type === 'static') {
+            return segment.name;
+        }
+        // Dynamic segment - normalize the parameter name by replacing the
+        // parameter name with a wildcard. The interception marker is already
+        // included in the segment name, so no special handling is needed.
+        return segment.name.replace(segment.param.paramName, '*');
+    }).join('/');
+}
+function validateAppPaths(appPaths) {
+    // First, validate each path individually
+    const paramsByPath = new Map();
+    for (const path of appPaths){
+        paramsByPath.set(path, parseAndValidateAppPath(path));
+    }
+    // Group paths by their normalized structure for ambiguity detection
+    const structureMap = new Map();
+    for (const [path, route] of paramsByPath){
+        // Check if the last segment is an optional catch-all and check to see if
+        // there is a route with the same specificity that conflicts with it.
+        const lastSegment = route.segments[route.segments.length - 1];
+        if ((lastSegment == null ? void 0 : lastSegment.type) === 'dynamic' && lastSegment.param.paramType === 'optional-catchall') {
+            const prefixSegments = route.segments.slice(0, -1);
+            const normalizedPrefix = normalizeSegments(prefixSegments);
+            for (const [appPath, appRoute] of paramsByPath){
+                const normalizedAppPath = normalizeSegments(appRoute.segments);
+                // Special case: root-level optional catch-all
+                // /[[...slug]] has prefix '' which should match '/'
+                if (prefixSegments.length === 0 && appPath === '/') {
+                    throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as an optional catch-all route ("${appPath}" and "/[[...${lastSegment.param.paramName}]]").`), "__NEXT_ERROR_CODE", {
+                        value: "E925",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+                // General case: compare normalized structures
+                if (normalizedAppPath === normalizedPrefix) {
+                    throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as an optional catch-all route ("${appPath}" and "${normalizedPrefix}/[[...${lastSegment.param.paramName}]]").`), "__NEXT_ERROR_CODE", {
+                        value: "E917",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
+            }
+        }
+        // Normalize the route to get its structure
+        const structure = normalizeSegments(route.segments);
+        // Track which paths map to this structure
+        const existingPaths = structureMap.get(structure) ?? [];
+        existingPaths.push(path);
+        structureMap.set(structure, existingPaths);
+    }
+    // Check for ambiguous routes (different slug names, same structure)
+    const conflicts = [];
+    for (const [structure, paths] of structureMap){
+        if (paths.length > 1) {
+            // Multiple paths map to the same structure - this is ambiguous
+            conflicts.push({
+                paths,
+                normalizedPath: structure
+            });
+        }
+    }
+    if (conflicts.length > 0) {
+        const errorMessages = conflicts.map(({ paths, normalizedPath })=>{
+            const pathsList = paths.map((p)=>`  - ${p}`).join('\n');
+            return `Ambiguous route pattern "${normalizedPath}" matches multiple routes:\n${pathsList}`;
+        });
+        throw Object.defineProperty(new Error(`Ambiguous app routes detected:\n\n${errorMessages.join('\n\n')}\n\n` + `These routes cannot be distinguished from each other when matching URLs. ` + `Please ensure that dynamic segments have unique patterns or use different static segments.`), "__NEXT_ERROR_CODE", {
+            value: "E912",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return Array.from(paramsByPath.values());
+}
+
+//# sourceMappingURL=validate-app-paths.js.map

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-app-loader/index.js

@@ -25,8 +25,10 @@ const _loadentrypoint = require("../../../load-entrypoint");
 const _segment = require("../../../../shared/lib/segment");
 const _getfilesindir = require("../../../../lib/get-files-in-dir");
 const _default = require("../../../../client/components/builtin/default");
+const _defaultnull = require("../../../../client/components/builtin/default-null");
 const _createapproutecode = require("./create-app-route-code");
 const _missingdefaultparallelrouteerror = require("../../../../shared/lib/errors/missing-default-parallel-route-error");
+const _interceptionroutes = require("../../../../shared/lib/router/utils/interception-routes");
 const _normalizepathsep = require("../../../../shared/lib/page-path/normalize-path-sep");
 const _installbindings = require("../../../swc/install-bindings");
 function _interop_require_default(obj) {
@@ -418,7 +420,18 @@ async function createTreeCodeFromPath(pagePath, { page, resolveDir, resolver, re
                 let defaultPath = await resolver(`${fullSegmentPath}/default`);
                 if (!defaultPath) {
                     if (adjacentParallelSegment === 'children') {
-                        defaultPath = _default.PARALLEL_ROUTE_DEFAULT_PATH;
+                        // When we host applications on Vercel, the status code affects the
+                        // underlying behavior of the route, which when we are missing the
+                        // children slot of an interception route, will yield a full 404
+                        // response for the RSC request instead. For this reason, we expect
+                        // that if a default file is missing when we're rendering an
+                        // interception route, we instead always render null for the default
+                        // slot to avoid the full 404 response.
+                        if ((0, _interceptionroutes.isInterceptionRouteAppPath)(page)) {
+                            defaultPath = _defaultnull.PARALLEL_ROUTE_DEFAULT_NULL_PATH;
+                        } else {
+                            defaultPath = _default.PARALLEL_ROUTE_DEFAULT_PATH;
+                        }
                     } else {
                         // Check if we're inside a catch-all route (i.e., the parallel route is a child
                         // of a catch-all segment). Only skip validation if the slot is UNDER a catch-all.
@@ -491,7 +504,12 @@ const nextAppLoader = async function nextAppLoader() {
     }
     const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
     const collectedDeclarations = [];
-    const page = name.replace(/^app/, '');
+    // Use the page from loaderOptions directly instead of deriving it from name.
+    // The name (bundlePath) may have been normalized with normalizePagePath()
+    // which is designed for Pages Router and incorrectly duplicates /index paths
+    // (e.g., /index/page -> /index/index/page). The page parameter contains the
+    // correct unnormalized value.
+    const page = loaderOptions.page;
     const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
     buildInfo.route = {
         page,

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-edge-app-route-loader/index.js

@@ -14,7 +14,7 @@ const _constants = require("../../../../lib/constants");
 const _loadentrypoint = require("../../../load-entrypoint");
 const _ismetadataroute = require("../../../../lib/metadata/is-metadata-route");
 const EdgeAppRouteLoader = async function() {
-    const { page, absolutePagePath, preferredRegion, appDirLoader: appDirLoaderBase64 = '', middlewareConfig: middlewareConfigBase64 = '', nextConfig: nextConfigBase64, cacheHandlers: cacheHandlersStringified } = this.getOptions();
+    const { page, absolutePagePath, preferredRegion, appDirLoader: appDirLoaderBase64 = '', middlewareConfig: middlewareConfigBase64 = '', cacheHandlers: cacheHandlersStringified } = this.getOptions();
     const appDirLoader = Buffer.from(appDirLoaderBase64, 'base64').toString();
     const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
     const cacheHandlers = JSON.parse(cacheHandlersStringified || '{}');
@@ -41,13 +41,10 @@ const EdgeAppRouteLoader = async function() {
     };
     const stringifiedPagePath = (0, _stringifyrequest.stringifyRequest)(this, absolutePagePath);
     const modulePath = `${appDirLoader}${stringifiedPagePath.substring(1, stringifiedPagePath.length - 1)}?${_constants.WEBPACK_RESOURCE_QUERIES.edgeSSREntry}`;
-    const stringifiedConfig = Buffer.from(nextConfigBase64 || '', 'base64').toString();
     return await (0, _loadentrypoint.loadEntrypoint)('edge-app-route', {
         VAR_USERLAND: modulePath,
         VAR_PAGE: page
-    }, {
-        nextConfig: stringifiedConfig
-    });
+    }, {});
 };
 const _default = EdgeAppRouteLoader;
 

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-edge-ssr-loader/index.js

@@ -32,21 +32,17 @@ function getRouteModuleOptions(page) {
             // The following aren't used in production.
             bundlePath: '',
             filename: ''
-        },
-        // edge runtime doesn't read from distDir or projectDir
-        distDir: '',
-        relativeProjectDir: ''
+        }
     };
     return options;
 }
 const edgeSSRLoader = async function edgeSSRLoader() {
-    const { page, absolutePagePath, absoluteAppPath, absoluteDocumentPath, absolute500Path, absoluteErrorPath, isServerComponent, stringifiedConfig: stringifiedConfigBase64, appDirLoader: appDirLoaderBase64, pagesType, cacheHandler, cacheHandlers: cacheHandlersStringified, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
+    const { page, absolutePagePath, absoluteAppPath, absoluteDocumentPath, absolute500Path, absoluteErrorPath, isServerComponent, appDirLoader: appDirLoaderBase64, pagesType, cacheHandler, cacheHandlers: cacheHandlersStringified, preferredRegion, middlewareConfig: middlewareConfigBase64 } = this.getOptions();
     const cacheHandlers = JSON.parse(cacheHandlersStringified || '{}');
     if (!cacheHandlers.default) {
         cacheHandlers.default = require.resolve('../../../../server/lib/cache-handlers/default.external');
     }
     const middlewareConfig = JSON.parse(Buffer.from(middlewareConfigBase64, 'base64').toString());
-    const stringifiedConfig = Buffer.from(stringifiedConfigBase64 || '', 'base64').toString();
     const appDirLoader = Buffer.from(appDirLoaderBase64 || '', 'base64').toString();
     const isAppDir = pagesType === 'app';
     const buildInfo = (0, _getmodulebuildinfo.getModuleBuildInfo)(this._module);
@@ -72,20 +68,17 @@ const edgeSSRLoader = async function edgeSSRLoader() {
         return await (0, _loadentrypoint.loadEntrypoint)('edge-ssr-app', {
             VAR_USERLAND: pageModPath,
             VAR_PAGE: page
-        }, {
-            nextConfig: stringifiedConfig
-        }, {
+        }, {}, {
             incrementalCacheHandler: cacheHandler ?? null
         });
     } else {
         return await (0, _loadentrypoint.loadEntrypoint)('edge-ssr', {
             VAR_USERLAND: pageModPath,
-            VAR_PAGE: page,
+            VAR_DEFINITION_PATHNAME: page,
             VAR_MODULE_DOCUMENT: documentPath,
             VAR_MODULE_APP: appPath,
             VAR_MODULE_GLOBAL_ERROR: errorPath
         }, {
-            nextConfig: stringifiedConfig,
             pageRouteModuleOptions: JSON.stringify(getRouteModuleOptions(page)),
             errorRouteModuleOptions: JSON.stringify(getRouteModuleOptions('/_error')),
             user500RouteModuleOptions: JSON.stringify(getRouteModuleOptions('/500'))

qalita/_frontend/node_modules/next/dist/build/webpack/loaders/next-root-params-loader.js

@@ -155,7 +155,7 @@ function getParamsFromLayoutFilePath({ appDir, layoutFilePath }) {
     for (const segment of segments){
         const param = (0, _getsegmentparam.getSegmentParam)(segment);
         if (param !== null) {
-            paramNames.push(param.param);
+            paramNames.push(param.paramName);
         }
     }
     return paramNames;

qalita/_frontend/node_modules/next/dist/build/webpack/plugins/flight-manifest-plugin.js

@@ -19,7 +19,7 @@ const _constants = require("../../../shared/lib/constants");
 const _buildcontext = require("../../build-context");
 const _constants1 = require("../../../lib/constants");
 const _normalizepagepath = require("../../../shared/lib/page-path/normalize-page-path");
-const _deploymentid = require("../../deployment-id");
+const _deploymentid = require("../../../shared/lib/deployment-id");
 const _utils = require("../utils");
 const _encodeuripath = require("../../../shared/lib/encode-uri-path");
 function _getRequireWildcardCache(nodeInterop) {

qalita/_frontend/node_modules/next/dist/build/webpack/plugins/middleware-plugin.js

@@ -81,6 +81,9 @@ function getEntryFiles(entryFiles, meta, hasInstrumentationHook, opts) {
             files.push(`server/${_constants.DYNAMIC_CSS_MANIFEST}.js`);
         }
         files.push(`server/${_constants.MIDDLEWARE_BUILD_MANIFEST}.js`, `server/${_constants.MIDDLEWARE_REACT_LOADABLE_MANIFEST}.js`, `server/${_constants.NEXT_FONT_MANIFEST}.js`, `server/${_constants.INTERCEPTION_ROUTE_REWRITE_MANIFEST}.js`);
+        if (!opts.dev) {
+            files.push(`${_constants.SERVER_FILES_MANIFEST}.js`);
+        }
     }
     if (hasInstrumentationHook) {
         files.push(`server/edge-${_constants1.INSTRUMENTATION_HOOK_FILENAME}.js`);

qalita/_frontend/node_modules/next/dist/build/webpack-build/impl.js

@@ -371,6 +371,7 @@ async function workerMain(workerData) {
         result.buildTraceContext.chunksTrace.entryNameFilesMap = entryNameFilesMap;
     }
     _buildcontext.NextBuildContext.nextBuildSpan.stop();
+    await telemetry.flush();
     return {
         ...result,
         debugTraceEvents: (0, _trace.getTraceEvents)()

qalita/_frontend/node_modules/next/dist/build/webpack-config.js

@@ -62,6 +62,7 @@ const _picocolors = require("../lib/picocolors");
 const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
 const _webpack = require("next/dist/compiled/webpack/webpack");
 const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 const _defineenv = require("./define-env");
 const _escaperegexp = require("../shared/lib/escape-regexp");
 const _constants = require("../lib/constants");
@@ -103,6 +104,7 @@ const _getrspack = require("../shared/lib/get-rspack");
 const _rspackprofilingplugin = require("./webpack/plugins/rspack-profiling-plugin");
 const _getwebpackbundler = /*#__PURE__*/ _interop_require_default(require("../shared/lib/get-webpack-bundler"));
 const _requirehook = require("../server/require-hook");
+const _json5 = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/json5"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -149,7 +151,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const EXTERNAL_PACKAGES = require('../lib/server-external-packages.json');
+const EXTERNAL_PACKAGES = _json5.default.parse(_fs.default.readFileSync(_path.default.join(__dirname, '../lib/server-external-packages.jsonc'), 'utf8'));
 const DEFAULT_TRANSPILED_PACKAGES = require('../lib/default-transpiled-packages.json');
 if (parseInt(_react.default.version) < 18) {
     throw Object.defineProperty(new Error('Next.js requires react >= 18.2.0 to be installed.'), "__NEXT_ERROR_CODE", {
@@ -1723,7 +1725,7 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
             isClient && new _copyfileplugin.CopyFilePlugin({
                 // file path to build output of `@next/polyfill-nomodule`
                 filePath: require.resolve('./polyfills/polyfill-nomodule'),
-                cacheKey: "16.0.10",
+                cacheKey: "16.1.1",
                 name: `static/chunks/polyfills${dev ? '' : '-[hash]'}.js`,
                 minimize: false,
                 info: {
@@ -1819,6 +1821,14 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
     if (isRspack) {
         // The layers experiment is now stable in Rspack
         delete webpack5Config.experiments.layers;
+        if (!webpack5Config.node) {
+            webpack5Config.node = {};
+        }
+        // NOTE: Rspack's defaults differ from webpack.
+        if (isClient || isEdgeServer) {
+            webpack5Config.node.__dirname = 'mock';
+            webpack5Config.node.__filename = 'mock';
+        }
     }
     webpack5Config.module.parser = {
         javascript: {
@@ -1909,7 +1919,7 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
         //  - Next.js location on disk (some loaders use absolute paths and some resolve options depend on absolute paths)
         //  - Next.js version
         //  - next.config.js keys that affect compilation
-        version: `${__dirname}|${"16.0.10"}|${configVars}`,
+        version: `${__dirname}|${"16.1.1"}|${configVars}`,
         cacheDirectory: _path.default.join(distDir, 'cache', 'webpack'),
         // For production builds, it's more efficient to compress all cache files together instead of compression each one individually.
         // So we disable compression here and allow the build runner to take care of compressing the cache as a whole.
@@ -1946,6 +1956,28 @@ async function getBaseWebpackConfig(dir, { buildId, encryptionKey, config, compi
         });
     });
     webpack5Config.cache = cache;
+    if (isRspack) {
+        const buildDependencies = [];
+        if (config.configFile) {
+            buildDependencies.push(config.configFile);
+        }
+        if (babelConfigFile) {
+            buildDependencies.push(babelConfigFile);
+        }
+        if (jsConfigPath) {
+            buildDependencies.push(jsConfigPath);
+        }
+        // @ts-ignore
+        webpack5Config.experiments.cache = {
+            type: 'persistent',
+            buildDependencies,
+            storage: {
+                type: 'filesystem',
+                directory: cache.cacheDirectory
+            },
+            version: `${__dirname}|${"16.1.1"}|${configVars}`
+        };
+    }
     if (process.env.NEXT_WEBPACK_LOGGING) {
         const infra = process.env.NEXT_WEBPACK_LOGGING.includes('infrastructure');
         const profileClient = process.env.NEXT_WEBPACK_LOGGING.includes('profile-client');