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

qalita/_frontend/node_modules/next/dist/server/config-schema.js

@@ -290,6 +290,7 @@ const experimentalSchema = {
             ]).optional()
         })
     ]).optional(),
+    transitionIndicator: _zod.z.boolean().optional(),
     typedRoutes: _zod.z.boolean().optional(),
     webpackBuildWorker: _zod.z.boolean().optional(),
     webpackMemoryOptimizations: _zod.z.boolean().optional(),
@@ -298,9 +299,13 @@ const experimentalSchema = {
     turbopackFileSystemCacheForDev: _zod.z.boolean().optional(),
     turbopackFileSystemCacheForBuild: _zod.z.boolean().optional(),
     turbopackSourceMaps: _zod.z.boolean().optional(),
+    turbopackInputSourceMaps: _zod.z.boolean().optional(),
     turbopackTreeShaking: _zod.z.boolean().optional(),
+    turbopackRemoveUnusedImports: _zod.z.boolean().optional(),
     turbopackRemoveUnusedExports: _zod.z.boolean().optional(),
     turbopackScopeHoisting: _zod.z.boolean().optional(),
+    turbopackClientSideNestedAsyncChunking: _zod.z.boolean().optional(),
+    turbopackServerSideNestedAsyncChunking: _zod.z.boolean().optional(),
     turbopackImportTypeBytes: _zod.z.boolean().optional(),
     turbopackUseSystemTlsCerts: _zod.z.boolean().optional(),
     turbopackUseBuiltinBabel: _zod.z.boolean().optional(),
@@ -309,6 +314,7 @@ const experimentalSchema = {
         'named',
         'deterministic'
     ]).optional(),
+    turbopackInferModuleSideEffects: _zod.z.boolean().optional(),
     optimizePackageImports: _zod.z.array(_zod.z.string()).optional(),
     optimizeServerReact: _zod.z.boolean().optional(),
     clientTraceMetadata: _zod.z.array(_zod.z.string()).optional(),
@@ -340,7 +346,8 @@ const experimentalSchema = {
         })
     ]).optional(),
     lockDistDir: _zod.z.boolean().optional(),
-    hideLogsAfterAbort: _zod.z.boolean().optional()
+    hideLogsAfterAbort: _zod.z.boolean().optional(),
+    runtimeServerDeploymentId: _zod.z.boolean().optional()
 };
 const configSchema = _zod.z.lazy(()=>_zod.z.strictObject({
         allowedDevOrigins: _zod.z.array(_zod.z.string()).optional(),

qalita/_frontend/node_modules/next/dist/server/config-shared.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     defaultConfig: null,
+    getNextConfigRuntime: null,
     normalizeConfig: null
 });
 function _export(target, all) {
@@ -16,6 +17,9 @@ _export(exports, {
     defaultConfig: function() {
         return defaultConfig;
     },
+    getNextConfigRuntime: function() {
+        return getNextConfigRuntime;
+    },
     normalizeConfig: function() {
         return normalizeConfig;
     }
@@ -136,7 +140,6 @@ const defaultConfig = Object.freeze({
         appNavFailHandling: false,
         prerenderEarlyExit: true,
         serverMinification: true,
-        serverSourceMaps: false,
         linkNoTouchStart: false,
         caseSensitiveRoutes: false,
         clientParamParsingOrigins: undefined,
@@ -197,6 +200,7 @@ const defaultConfig = Object.freeze({
         serverComponentsHmrCache: true,
         staticGenerationMaxConcurrency: 8,
         staticGenerationMinPagesPerWorker: 25,
+        transitionIndicator: false,
         inlineCss: false,
         useCache: undefined,
         slowModuleDetection: undefined,
@@ -206,7 +210,10 @@ const defaultConfig = Object.freeze({
         isolatedDevBuild: true,
         proxyClientMaxBodySize: 10485760,
         hideLogsAfterAbort: false,
-        mcpServer: true
+        mcpServer: true,
+        turbopackFileSystemCacheForDev: true,
+        turbopackFileSystemCacheForBuild: false,
+        turbopackInferModuleSideEffects: !(0, _canaryonlyconfigerror.isStableBuild)()
     },
     htmlLimitedBots: undefined,
     bundlePagesRouterDependencies: false
@@ -220,5 +227,79 @@ async function normalizeConfig(phase, config) {
     // Support `new Promise` and `async () =>` as return values of the config export
     return await config;
 }
+function getNextConfigRuntime(config) {
+    let ex = config.experimental;
+    let experimental = ex ? {
+        ppr: ex.ppr,
+        taint: ex.taint,
+        serverActions: ex.serverActions,
+        staleTimes: ex.staleTimes,
+        dynamicOnHover: ex.dynamicOnHover,
+        inlineCss: ex.inlineCss,
+        authInterrupts: ex.authInterrupts,
+        clientTraceMetadata: ex.clientTraceMetadata,
+        clientParamParsingOrigins: ex.clientParamParsingOrigins,
+        adapterPath: ex.adapterPath,
+        allowedRevalidateHeaderKeys: ex.allowedRevalidateHeaderKeys,
+        fetchCacheKeyPrefix: ex.fetchCacheKeyPrefix,
+        isrFlushToDisk: ex.isrFlushToDisk,
+        optimizeCss: ex.optimizeCss,
+        nextScriptWorkers: ex.nextScriptWorkers,
+        disableOptimizedLoading: ex.disableOptimizedLoading,
+        largePageDataBytes: ex.largePageDataBytes,
+        serverComponentsHmrCache: ex.serverComponentsHmrCache,
+        caseSensitiveRoutes: ex.caseSensitiveRoutes,
+        validateRSCRequestHeaders: ex.validateRSCRequestHeaders,
+        sri: ex.sri,
+        useSkewCookie: ex.useSkewCookie,
+        preloadEntriesOnStart: ex.preloadEntriesOnStart,
+        hideLogsAfterAbort: ex.hideLogsAfterAbort,
+        removeUncaughtErrorAndRejectionListeners: ex.removeUncaughtErrorAndRejectionListeners,
+        imgOptConcurrency: ex.imgOptConcurrency,
+        imgOptMaxInputPixels: ex.imgOptMaxInputPixels,
+        imgOptSequentialRead: ex.imgOptSequentialRead,
+        imgOptSkipMetadata: ex.imgOptSkipMetadata,
+        imgOptTimeoutInSeconds: ex.imgOptTimeoutInSeconds,
+        proxyClientMaxBodySize: ex.proxyClientMaxBodySize,
+        proxyTimeout: ex.proxyTimeout,
+        testProxy: ex.testProxy,
+        runtimeServerDeploymentId: ex.runtimeServerDeploymentId,
+        trustHostHeader: ex.trustHostHeader,
+        isExperimentalCompile: ex.isExperimentalCompile
+    } : {};
+    let runtimeConfig = {
+        deploymentId: config.experimental.runtimeServerDeploymentId ? '' : config.deploymentId,
+        configFileName: undefined,
+        env: undefined,
+        distDir: config.distDir,
+        cacheComponents: config.cacheComponents,
+        htmlLimitedBots: config.htmlLimitedBots,
+        assetPrefix: config.assetPrefix,
+        output: config.output,
+        crossOrigin: config.crossOrigin,
+        trailingSlash: config.trailingSlash,
+        images: config.images,
+        reactMaxHeadersLength: config.reactMaxHeadersLength,
+        cacheLife: config.cacheLife,
+        basePath: config.basePath,
+        expireTime: config.expireTime,
+        generateEtags: config.generateEtags,
+        poweredByHeader: config.poweredByHeader,
+        cacheHandler: config.cacheHandler,
+        cacheHandlers: config.cacheHandlers,
+        cacheMaxMemorySize: config.cacheMaxMemorySize,
+        compress: config.compress,
+        i18n: config.i18n,
+        httpAgentOptions: config.httpAgentOptions,
+        skipProxyUrlNormalize: config.skipProxyUrlNormalize,
+        pageExtensions: config.pageExtensions,
+        useFileSystemPublicRoutes: config.useFileSystemPublicRoutes,
+        experimental
+    };
+    if (config.experimental.isExperimentalCompile) {
+        runtimeConfig.env = config.env;
+    }
+    return runtimeConfig;
+}
 
 //# sourceMappingURL=config-shared.js.map

qalita/_frontend/node_modules/next/dist/server/config.js

@@ -49,7 +49,6 @@ const _dset = require("../shared/lib/dset");
 const _zod = require("../shared/lib/zod");
 const _isbot = require("../shared/lib/router/utils/is-bot");
 const _findpagesdir = require("../lib/find-pages-dir");
-const _canaryonlyconfigerror = require("../shared/lib/errors/canary-only-config-error");
 const _interopdefault = require("../lib/interop-default");
 const _hash = require("../shared/lib/hash");
 const _harddeprecatedconfigerror = require("../shared/lib/errors/hard-deprecated-config-error");
@@ -215,7 +214,7 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
  * @param silent - Whether to suppress warnings.
  * @returns The complete config.
  */ function assignDefaultsAndValidate(dir, userConfig, silent, phase) {
-    var _result_experimental, _result_experimental1, _result_experimental_serverActions, _result_experimental2, _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3, _userConfig_experimental4, _userConfig_experimental5, _userConfig_experimental6, _userConfig_experimental7, _userConfig_experimental8, _userConfig_experimental9, _userConfig_experimental10, _userConfig_experimental11, _userConfig_experimental12, _userConfig_experimental13, _userConfig_experimental14, _userConfig_experimental15, _result_experimental3, _result_turbopack, _result_turbopack1, _result_devIndicators, _result_experimental4, _result_experimental5;
+    var _result_experimental, _result_experimental_serverActions, _result_experimental1, _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3, _userConfig_experimental4, _userConfig_experimental5, _userConfig_experimental6, _userConfig_experimental7, _userConfig_experimental8, _userConfig_experimental9, _userConfig_experimental10, _userConfig_experimental11, _userConfig_experimental12, _userConfig_experimental13, _userConfig_experimental14, _userConfig_experimental15, _result_experimental2, _result_turbopack, _result_turbopack1, _result_devIndicators, _result_experimental3;
     const configFileName = userConfig.configFileName;
     if (typeof userConfig.exportTrailingSlash !== 'undefined') {
         if (!silent) {
@@ -310,10 +309,10 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
         }
     };
     // ensure correct default is set for api-resolver revalidate handling
-    if (!((_result_experimental = result.experimental) == null ? void 0 : _result_experimental.trustHostHeader) && _ciinfo.hasNextSupport) {
+    if (!result.experimental.trustHostHeader && _ciinfo.hasNextSupport) {
         result.experimental.trustHostHeader = true;
     }
-    if (((_result_experimental1 = result.experimental) == null ? void 0 : _result_experimental1.allowDevelopmentBuild) && process.env.NODE_ENV !== 'development') {
+    if (((_result_experimental = result.experimental) == null ? void 0 : _result_experimental.allowDevelopmentBuild) && process.env.NODE_ENV !== 'development') {
         throw Object.defineProperty(new Error(`The experimental.allowDevelopmentBuild option requires NODE_ENV to be explicitly set to 'development'.`), "__NEXT_ERROR_CODE", {
             value: "E195",
             enumerable: false,
@@ -328,15 +327,6 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
             configurable: true
         });
     }
-    if ((0, _canaryonlyconfigerror.isStableBuild)()) {
-        var _result_experimental6;
-        // Prevents usage of certain experimental features outside of canary
-        if ((_result_experimental6 = result.experimental) == null ? void 0 : _result_experimental6.turbopackFileSystemCacheForBuild) {
-            throw new _canaryonlyconfigerror.CanaryOnlyConfigError({
-                feature: 'experimental.turbopackFileSystemCacheForBuild'
-            });
-        }
-    }
     if (result.experimental.ppr) {
         throw new _harddeprecatedconfigerror.HardDeprecatedConfigError(`\`experimental.ppr\` has been merged into \`cacheComponents\`. The Partial Prerendering feature is still available, but is now enabled via \`cacheComponents\`. Please update your ${configFileName} accordingly.`);
     }
@@ -563,7 +553,7 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
         }
         result.output = 'standalone';
     }
-    if (typeof ((_result_experimental2 = result.experimental) == null ? void 0 : (_result_experimental_serverActions = _result_experimental2.serverActions) == null ? void 0 : _result_experimental_serverActions.bodySizeLimit) !== 'undefined') {
+    if (typeof ((_result_experimental1 = result.experimental) == null ? void 0 : (_result_experimental_serverActions = _result_experimental1.serverActions) == null ? void 0 : _result_experimental_serverActions.bodySizeLimit) !== 'undefined') {
         var _result_experimental_serverActions1;
         const value = parseInt((_result_experimental_serverActions1 = result.experimental.serverActions) == null ? void 0 : _result_experimental_serverActions1.bodySizeLimit.toString());
         if (isNaN(value) || value < 1) {
@@ -628,7 +618,7 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
         result.skipMiddlewareUrlNormalize = userConfig.skipProxyUrlNormalize;
     }
     // Normalize & validate experimental.proxyClientMaxBodySize
-    if (typeof ((_result_experimental3 = result.experimental) == null ? void 0 : _result_experimental3.proxyClientMaxBodySize) !== 'undefined') {
+    if (typeof ((_result_experimental2 = result.experimental) == null ? void 0 : _result_experimental2.proxyClientMaxBodySize) !== 'undefined') {
         const proxyClientMaxBodySize = result.experimental.proxyClientMaxBodySize;
         let normalizedValue;
         if (typeof proxyClientMaxBodySize === 'string') {
@@ -668,6 +658,16 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
             _log.warn(`turbopack.root should be absolute, using: ${result.turbopack.root}`);
         }
     }
+    if (result.experimental.runtimeServerDeploymentId == null && phase === _constants.PHASE_PRODUCTION_BUILD && _ciinfo.hasNextSupport && process.env.NEXT_DEPLOYMENT_ID) {
+        if (result.deploymentId != null && result.deploymentId !== process.env.NEXT_DEPLOYMENT_ID) {
+            throw Object.defineProperty(new Error(`The NEXT_DEPLOYMENT_ID environment variable value "${process.env.NEXT_DEPLOYMENT_ID}" does not match the provided deploymentId "${result.deploymentId}" in the config.`), "__NEXT_ERROR_CODE", {
+                value: "E971",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        result.experimental.runtimeServerDeploymentId = true;
+    }
     // only leverage deploymentId
     if (process.env.NEXT_DEPLOYMENT_ID) {
         result.deploymentId = process.env.NEXT_DEPLOYMENT_ID;
@@ -928,7 +928,7 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
             transform: 'lodash/{{member}}'
         }
     };
-    const userProvidedOptimizePackageImports = ((_result_experimental4 = result.experimental) == null ? void 0 : _result_experimental4.optimizePackageImports) || [];
+    const userProvidedOptimizePackageImports = ((_result_experimental3 = result.experimental) == null ? void 0 : _result_experimental3.optimizePackageImports) || [];
     result.experimental.optimizePackageImports = [
         ...new Set([
             ...userProvidedOptimizePackageImports,
@@ -1037,7 +1037,7 @@ function warnCustomizedOption(config, key, defaultValue, customMessage, configFi
     // Store the distDirRoot in the config before it is modified by the isolatedDevBuild flag
     ;
     result.distDirRoot = result.distDir;
-    if (phase === _constants.PHASE_DEVELOPMENT_SERVER && ((_result_experimental5 = result.experimental) == null ? void 0 : _result_experimental5.isolatedDevBuild)) {
+    if (phase === _constants.PHASE_DEVELOPMENT_SERVER && result.experimental.isolatedDevBuild) {
         result.distDir = (0, _path.join)(result.distDir, 'dev');
     }
     return result;
@@ -1344,6 +1344,13 @@ function enforceExperimentalFeatures(config, options) {
             addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'reactDebugChannel', true, 'enabled by `__NEXT_EXPERIMENTAL_DEBUG_CHANNEL`');
         }
     }
+    if (process.env.__NEXT_EXPERIMENTAL_TRANSITION_INDICATOR === 'true' && // We do respect an explicit value in the user config.
+    (config.experimental.transitionIndicator === undefined || isDefaultConfig && !config.experimental.transitionIndicator)) {
+        config.experimental.transitionIndicator = true;
+        if (configuredExperimentalFeatures) {
+            addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'transitionIndicator', true, 'enabled by `__NEXT_EXPERIMENTAL_TRANSITION_INDICATOR`');
+        }
+    }
     if (process.env.__NEXT_ENABLE_REACT_COMPILER === 'true' && // We do respect an explicit value in the user config.
     (config.reactCompiler === undefined || isDefaultConfig && !config.reactCompiler)) {
         config.reactCompiler = true;

qalita/_frontend/node_modules/next/dist/server/dev/hot-reloader-rspack.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Rspack Persistent Cache Strategy for Next.js Development
+ *
+ * Rspack's persistent caching differs from Webpack in how it manages module graphs.
+ * While Webpack incrementally updates modules, Rspack operates on complete module
+ * graph snapshots for cache restoration.
+ *
+ * Problem:
+ * - Next.js dev server starts with no page modules in the initial entry points
+ * - When Rspack restores from persistent cache, it finds no modules and purges
+ *   the entire module graph
+ * - Later page requests find no cached module information, preventing cache reuse
+ *
+ * Solution:
+ * - Track successfully built page entries after each compilation
+ * - Restore these entries on dev server restart to maintain module graph continuity
+ * - This ensures previously compiled pages can leverage persistent cache for faster builds
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return HotReloaderRspack;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _crypto = require("crypto");
+const _hotreloaderwebpack = /*#__PURE__*/ _interop_require_default(require("./hot-reloader-webpack"));
+const _ondemandentryhandler = require("./on-demand-entry-handler");
+const _constants = require("../../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class HotReloaderRspack extends _hotreloaderwebpack.default {
+    async afterCompile(multiCompiler) {
+        // Always initialize the fallback error watcher for Rspack.
+        // Rspack may restore/retain the previous build's error state, so without this
+        // a page that previously failed to build might not be rebuilt on the next request.
+        await super.buildFallbackError();
+        const rspackStartSpan = this.hotReloaderSpan.traceChild('rspack-after-compile');
+        await rspackStartSpan.traceAsyncFn(async ()=>{
+            const hash = (0, _crypto.createHash)('sha1');
+            multiCompiler.compilers.forEach((compiler)=>{
+                const cache = compiler.options.cache;
+                if (typeof cache === 'object' && 'version' in cache && cache.version) {
+                    hash.update(cache.version);
+                    if (compiler.name === _constants.COMPILER_NAMES.client) {
+                        this.isClientCacheEnabled = true;
+                    } else if (compiler.name === _constants.COMPILER_NAMES.server) {
+                        this.isServerCacheEnabled = true;
+                    } else if (compiler.name === _constants.COMPILER_NAMES.edgeServer) {
+                        this.isEdgeServerCacheEnabled = true;
+                    }
+                } else {
+                    hash.update('-');
+                }
+                return undefined;
+            });
+            this.builtEntriesCachePath = _path.default.join(this.distDir, 'cache', 'rspack', hash.digest('hex').substring(0, 16), 'built-entries.json');
+            const hasBuiltEntriesCache = await _promises.default.access(this.builtEntriesCachePath).then(()=>true, ()=>false);
+            if (hasBuiltEntriesCache) {
+                try {
+                    const builtEntries = JSON.parse(await _promises.default.readFile(this.builtEntriesCachePath, 'utf-8') || '{}');
+                    await Promise.all(Object.keys(builtEntries).map(async (entryKey)=>{
+                        const entryData = builtEntries[entryKey];
+                        const isEntry = entryData.type === _ondemandentryhandler.EntryTypes.ENTRY;
+                        const isChildEntry = entryData.type === _ondemandentryhandler.EntryTypes.CHILD_ENTRY;
+                        // Check if the page was removed or disposed and remove it
+                        if (isEntry) {
+                            const pageExists = !entryData.dispose && await _promises.default.access(entryData.absolutePagePath).then(()=>true, ()=>false);
+                            if (!pageExists) {
+                                delete builtEntries[entryKey];
+                                return;
+                            } else if (!('hash' in builtEntries[entryKey]) || builtEntries[entryKey].hash !== await calculateFileHash(entryData.absolutePagePath)) {
+                                delete builtEntries[entryKey];
+                                return;
+                            }
+                        }
+                        // For child entries, if it has an entry file and it's gone, remove it
+                        if (isChildEntry) {
+                            if (entryData.absoluteEntryFilePath) {
+                                const pageExists = !entryData.dispose && await _promises.default.access(entryData.absoluteEntryFilePath).then(()=>true, ()=>false);
+                                if (!pageExists) {
+                                    delete builtEntries[entryKey];
+                                    return;
+                                } else {
+                                    if (!('hash' in builtEntries[entryKey]) || builtEntries[entryKey].hash !== await calculateFileHash(entryData.absoluteEntryFilePath)) {
+                                        delete builtEntries[entryKey];
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    }));
+                    Object.assign((0, _ondemandentryhandler.getEntries)(multiCompiler.outputPath), builtEntries);
+                } catch (error) {
+                    console.error('Rspack failed to read built entries cache: ', error);
+                }
+            }
+        });
+    }
+    async ensurePage({ page, clientOnly, appPaths, definition, isApp, url }) {
+        await super.ensurePage({
+            page,
+            clientOnly,
+            appPaths,
+            definition,
+            isApp,
+            url
+        });
+        const entries = (0, _ondemandentryhandler.getEntries)(this.multiCompiler.outputPath);
+        const builtEntries = {};
+        await Promise.all(Object.keys(entries).map(async (entryName)=>{
+            const entry = entries[entryName];
+            if (entry.status !== _ondemandentryhandler.BUILT) return;
+            const result = /^(client|server|edge-server)@(app|pages|root)@(.*)/g.exec(entryName);
+            const [, key /* pageType */ , , ] = result// this match should always happen
+            ;
+            if (key === 'client' && !this.isClientCacheEnabled) return;
+            if (key === 'server' && !this.isServerCacheEnabled) return;
+            if (key === 'edge-server' && !this.isEdgeServerCacheEnabled) return;
+            // TODO: Rspack does not store middleware entries in persistent cache, causing
+            // test/integration/middleware-src/test/index.test.ts to fail. This is a temporary
+            // workaround to skip middleware entry caching until Rspack properly supports it.
+            if (page === '/middleware') {
+                return;
+            }
+            let hash;
+            if (entry.type === _ondemandentryhandler.EntryTypes.ENTRY) {
+                hash = await calculateFileHash(entry.absolutePagePath);
+            } else if (entry.absoluteEntryFilePath) {
+                hash = await calculateFileHash(entry.absoluteEntryFilePath);
+            }
+            if (!hash) {
+                return;
+            }
+            builtEntries[entryName] = entry;
+            builtEntries[entryName].hash = hash;
+        }));
+        const hasBuitEntriesCache = await _promises.default.access(this.builtEntriesCachePath).then(()=>true, ()=>false);
+        try {
+            if (!hasBuitEntriesCache) {
+                await _promises.default.mkdir(_path.default.dirname(this.builtEntriesCachePath), {
+                    recursive: true
+                });
+            }
+            await _promises.default.writeFile(this.builtEntriesCachePath, JSON.stringify(builtEntries, null, 2));
+        } catch (error) {
+            console.error('Rspack failed to write built entries cache: ', error);
+        }
+    }
+    constructor(...args){
+        super(...args), this.isClientCacheEnabled = false, this.isServerCacheEnabled = false, this.isEdgeServerCacheEnabled = false;
+    }
+}
+async function calculateFileHash(filePath, algorithm = 'sha256') {
+    if (!await _promises.default.access(filePath).then(()=>true, ()=>false)) {
+        return;
+    }
+    const fileBuffer = await _promises.default.readFile(filePath);
+    const hash = (0, _crypto.createHash)(algorithm);
+    hash.update(fileBuffer);
+    return hash.digest('hex');
+}
+
+//# sourceMappingURL=hot-reloader-rspack.js.map

qalita/_frontend/node_modules/next/dist/server/dev/hot-reloader-turbopack.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "createHotReloaderTurbopack", {
     }
 });
 const _promises = require("fs/promises");
+const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
 const _path = require("path");
 const _url = require("url");
 const _ws = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ws"));
@@ -33,20 +34,20 @@ const _messages = require("./messages");
 const _encryptionutilsserver = require("../app-render/encryption-utils-server");
 const _apppageroutedefinition = require("../route-definitions/app-page-route-definition");
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
-const _utils2 = require("../lib/utils");
 const _ismetadataroute = require("../../lib/metadata/is-metadata-route");
 const _patcherrorinspect = require("../patch-error-inspect");
 const _getnexterrorfeedbackmiddleware = require("../../next-devtools/server/get-next-error-feedback-middleware");
-const _utils3 = require("../../shared/lib/turbopack/utils");
+const _utils2 = require("../../shared/lib/turbopack/utils");
 const _getdevoverlayfontmiddleware = require("../../next-devtools/server/font/get-dev-overlay-font-middleware");
 const _devindicatorserverstate = require("./dev-indicator-server-state");
 const _devindicatormiddleware = require("../../next-devtools/server/dev-indicator-middleware");
 const _restartdevservermiddleware = require("../../next-devtools/server/restart-dev-server-middleware");
 const _compilationevents = require("../../shared/lib/turbopack/compilation-events");
-const _utils4 = require("../../build/utils");
+const _utils3 = require("../../build/utils");
 const _receivelogs = require("./browser-logs/receive-logs");
 const _normalizepath = require("../../lib/normalize-path");
 const _devtoolsconfigmiddleware = require("../../next-devtools/server/devtools-config-middleware");
+const _attachnodejsdebuggermiddleware = require("../../next-devtools/server/attach-nodejs-debugger-middleware");
 const _debugchannel = require("./debug-channel");
 const _hotreloadersharedutils = require("./hot-reloader-shared-utils");
 const _getmcpmiddleware = require("../mcp/get-mcp-middleware");
@@ -55,6 +56,7 @@ const _getpagemetadata = require("../mcp/tools/get-page-metadata");
 const _formaterrors = require("../mcp/tools/utils/format-errors");
 const _mcptelemetrytracker = require("../mcp/mcp-telemetry-tracker");
 const _filelogger = require("./browser-logs/file-logger");
+const _serializederrors = require("./serialized-errors");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -151,7 +153,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-        version: "16.0.10"
+        version: "16.1.1"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -170,7 +172,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     if (nextConfig.experimental.clientRouterFilter) {
     // TODO this need to be set correctly for filesystem cache to work
     }
-    const supportedBrowsers = (0, _utils4.getSupportedBrowsers)(projectPath, dev);
+    const supportedBrowsers = (0, _utils3.getSupportedBrowsers)(projectPath, dev);
     const currentNodeJsVersion = process.versions.node;
     const rootPath = ((_opts_nextConfig_turbopack = opts.nextConfig.turbopack) == null ? void 0 : _opts_nextConfig_turbopack.root) || opts.nextConfig.outputFileTracingRoot || projectPath;
     const project = await bindings.turbo.createProject({
@@ -202,9 +204,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         previewProps: opts.fsChecker.prerenderManifest.preview,
         browserslistQuery: supportedBrowsers.join(', '),
         noMangling: false,
+        writeRoutesHashesManifest: false,
         currentNodeJsVersion
     }, {
-        persistentCaching: (0, _utils3.isFileSystemCacheEnabledForDev)(opts.nextConfig),
+        persistentCaching: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
         memoryLimit: (_opts_nextConfig_experimental = opts.nextConfig.experimental) == null ? void 0 : _opts_nextConfig_experimental.turbopackMemoryLimit,
         isShortSession: false
     });
@@ -409,7 +412,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         try {
             const changed = await changedPromise;
             for await (const change of changed){
-                (0, _utils3.processIssues)(currentEntryIssues, key, change, false, true);
+                (0, _utils2.processIssues)(currentEntryIssues, key, change, false, true);
                 // TODO: Get an actual content hash from Turbopack.
                 const message = await createMessage(change, String(++hmrHash));
                 if (message) {
@@ -451,7 +454,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         try {
             await subscription.next();
             for await (const data of subscription){
-                (0, _utils3.processIssues)(state.clientIssues, key, data, false, true);
+                (0, _utils2.processIssues)(state.clientIssues, key, data, false, true);
                 if (data.type !== 'issues') {
                     sendTurbopackMessage(data);
                 }
@@ -490,7 +493,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             (0, _turbopackutils.processTopLevelIssues)(currentTopLevelIssues, entrypoints);
             // Certain crtical issues prevent any entrypoints from being constructed so return early
             if (!('routes' in entrypoints)) {
-                (0, _utils4.printBuildErrors)(entrypoints, true);
+                (0, _utils3.printBuildErrors)(entrypoints, true);
                 currentEntriesHandlingResolve();
                 currentEntriesHandlingResolve = undefined;
                 continue;
@@ -603,6 +606,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 });
             }
         }),
+        (0, _attachnodejsdebuggermiddleware.getAttachNodejsDebuggerMiddleware)(),
         ...nextConfig.experimental.mcpServer ? [
             (0, _getmcpmiddleware.getMcpMiddleware)({
                 projectPath,
@@ -638,14 +642,12 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         return versionInfoCached;
     };
     let devtoolsFrontendUrl;
-    const nodeOptions = (0, _utils2.getParsedNodeOptions)();
-    const nodeDebugType = (0, _utils2.getNodeDebugType)(nodeOptions);
-    if (nodeDebugType) {
-        const debugPort = process.debugPort;
+    const inspectorURLRaw = _inspector.url();
+    if (inspectorURLRaw !== undefined) {
+        const inspectorURL = new URL(inspectorURLRaw);
         let debugInfo;
         try {
-            // It requires to use 127.0.0.1 instead of localhost for server-side fetching.
-            const debugInfoList = await fetch(`http://127.0.0.1:${debugPort}/json/list`).then((res)=>res.json());
+            const debugInfoList = await fetch(`http://${inspectorURL.host}/json/list`).then((res)=>res.json());
             debugInfo = debugInfoList[0];
         } catch  {}
         if (debugInfo) {
@@ -720,6 +722,8 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             isLegacyClient: true
                         });
                     }
+                    (0, _debugchannel.connectReactDebugChannelForHtmlRequest)(htmlRequestId, sendToClient.bind(null, client));
+                    (0, _serializederrors.sendSerializedErrorsToClientForHtmlRequest)(htmlRequestId, sendToClient.bind(null, client));
                 } else {
                     clientsWithoutHtmlRequestId.add(client);
                     onUpgrade(client, {
@@ -854,7 +858,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     for (const issue of entryIssues.values()){
                         if (issue.severity !== 'warning') {
                             errors.push({
-                                message: (0, _utils3.formatIssue)(issue)
+                                message: (0, _utils2.formatIssue)(issue)
                             });
                         } else {
                             (0, _turbopackutils.printNonFatalIssue)(issue);
@@ -881,9 +885,6 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                         devToolsConfig
                     };
                     sendToClient(client, syncMessage);
-                    if (htmlRequestId) {
-                        (0, _debugchannel.connectReactDebugChannelForHtmlRequest)(htmlRequestId, sendToClient.bind(null, client));
-                    }
                 })();
             });
         },
@@ -946,6 +947,17 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                 (0, _debugchannel.connectReactDebugChannel)(requestId, debugChannel, sendToClient.bind(null, client));
             }
         },
+        sendErrorsToBrowser (errorsRscStream, htmlRequestId) {
+            const client = clientsByHtmlRequestId.get(htmlRequestId);
+            if (client) {
+                // If the client is connected, we can send the errors immediately.
+                (0, _serializederrors.sendSerializedErrorsToClient)(errorsRscStream, sendToClient.bind(null, client));
+            } else {
+                // Otherwise, store the errors stream so that we can send it when the
+                // client connects.
+                (0, _serializederrors.setErrorsRscStreamForHtmlRequest)(htmlRequestId, errorsRscStream);
+            }
+        },
         setHmrServerError (_error) {
         // Not implemented yet.
         },
@@ -964,11 +976,11 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                     ...topLevelIssues,
                     ...thisEntryIssues.values()
                 ].map((issue)=>{
-                    const formattedIssue = (0, _utils3.formatIssue)(issue);
+                    const formattedIssue = (0, _utils2.formatIssue)(issue);
                     if (issue.severity === 'warning') {
                         (0, _turbopackutils.printNonFatalIssue)(issue);
                         return null;
-                    } else if ((0, _utils3.isWellKnownError)(issue)) {
+                    } else if ((0, _utils2.isWellKnownError)(issue)) {
                         _log.error(formattedIssue);
                     }
                     return Object.defineProperty(new Error(formattedIssue), "__NEXT_ERROR_CODE", {
@@ -982,7 +994,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             const errors = [];
             for (const issue of topLevelIssues){
                 if (issue.severity !== 'warning') {
-                    errors.push(Object.defineProperty(new Error((0, _utils3.formatIssue)(issue)), "__NEXT_ERROR_CODE", {
+                    errors.push(Object.defineProperty(new Error((0, _utils2.formatIssue)(issue)), "__NEXT_ERROR_CODE", {
                         value: "E394",
                         enumerable: false,
                         configurable: true
@@ -992,7 +1004,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
             for (const entryIssues of currentEntryIssues.values()){
                 for (const issue of entryIssues.values()){
                     if (issue.severity !== 'warning') {
-                        const message = (0, _utils3.formatIssue)(issue);
+                        const message = (0, _utils2.formatIssue)(issue);
                         errors.push(Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
                             value: "E394",
                             enumerable: false,
@@ -1179,10 +1191,10 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
                             for (const [key, issue] of issueMap){
                                 if (issue.severity === 'warning') continue;
                                 if (errorsMap.has(key)) continue;
-                                const message = (0, _utils3.formatIssue)(issue);
+                                const message = (0, _utils2.formatIssue)(issue);
                                 errorsMap.set(key, {
                                     message,
-                                    details: issue.detail ? (0, _utils3.renderStyledStringToErrorAnsi)(issue.detail) : undefined
+                                    details: issue.detail ? (0, _utils2.renderStyledStringToErrorAnsi)(issue.detail) : undefined
                                 });
                             }
                         }