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

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

@@ -44,6 +44,7 @@ var HMR_MESSAGE_SENT_TO_BROWSER = /*#__PURE__*/ function(HMR_MESSAGE_SENT_TO_BRO
     HMR_MESSAGE_SENT_TO_BROWSER["REQUEST_PAGE_METADATA"] = "requestPageMetadata";
     // Binary messages:
     HMR_MESSAGE_SENT_TO_BROWSER[HMR_MESSAGE_SENT_TO_BROWSER["REACT_DEBUG_CHUNK"] = 0] = "REACT_DEBUG_CHUNK";
+    HMR_MESSAGE_SENT_TO_BROWSER[HMR_MESSAGE_SENT_TO_BROWSER["ERRORS_TO_SHOW_IN_BROWSER"] = 1] = "ERRORS_TO_SHOW_IN_BROWSER";
     return HMR_MESSAGE_SENT_TO_BROWSER;
 }({});
 var HMR_MESSAGE_SENT_TO_SERVER = /*#__PURE__*/ function(HMR_MESSAGE_SENT_TO_SERVER) {

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

@@ -23,6 +23,7 @@ _export(exports, {
 const _webpack = require("next/dist/compiled/webpack/webpack");
 const _middlewarewebpack = require("./middleware-webpack");
 const _hotmiddleware = require("./hot-middleware");
+const _inspector = /*#__PURE__*/ _interop_require_wildcard(require("inspector"));
 const _path = require("path");
 const _entries = require("../../build/entries");
 const _getstaticinfoincludinglayouts = require("../../build/get-static-info-including-layouts");
@@ -50,7 +51,6 @@ const _routekind = require("../route-kind");
 const _hotreloadertypes = require("./hot-reloader-types");
 const _pagetypes = require("../../lib/page-types");
 const _messages = require("./messages");
-const _utils2 = require("../lib/utils");
 const _getnexterrorfeedbackmiddleware = require("../../next-devtools/server/get-next-error-feedback-middleware");
 const _getdevoverlayfontmiddleware = require("../../next-devtools/server/font/get-dev-overlay-font-middleware");
 const _devindicatormiddleware = require("../../next-devtools/server/dev-indicator-middleware");
@@ -59,6 +59,7 @@ const _restartdevservermiddleware = require("../../next-devtools/server/restart-
 const _cacheinvalidation = require("../../build/webpack/cache-invalidation");
 const _receivelogs = require("./browser-logs/receive-logs");
 const _devtoolsconfigmiddleware = require("../../next-devtools/server/devtools-config-middleware");
+const _attachnodejsdebuggermiddleware = require("../../next-devtools/server/attach-nodejs-debugger-middleware");
 const _invarianterror = require("../../shared/lib/invariant-error");
 const _debugchannel = require("./debug-channel");
 const _hotreloadersharedutils = require("./hot-reloader-shared-utils");
@@ -66,6 +67,7 @@ const _getmcpmiddleware = require("../mcp/get-mcp-middleware");
 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
@@ -231,7 +233,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.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.
@@ -502,6 +504,7 @@ class HotReloaderWebpack {
             });
             if (htmlRequestId) {
                 (0, _debugchannel.connectReactDebugChannelForHtmlRequest)(htmlRequestId, this.sendToClient.bind(this, client));
+                (0, _serializederrors.sendSerializedErrorsToClientForHtmlRequest)(htmlRequestId, this.sendToClient.bind(this, client));
                 if (enableCacheComponents) {
                     const status = this.cacheStatusesByRequestId.get(htmlRequestId);
                     if (status) {
@@ -665,15 +668,12 @@ class HotReloaderWebpack {
         startSpan.stop() // Stop immediately to create an artificial parent span
         ;
         this.versionInfo = await this.tracedGetVersionInfo(startSpan);
-        const nodeOptions = (0, _utils2.getParsedNodeOptions)();
-        const nodeDebugType = (0, _utils2.getNodeDebugType)(nodeOptions);
-        if (nodeDebugType && !this.devtoolsFrontendUrl) {
-            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());
-                // There will be only one item for current process, so always get the first item.
+                const debugInfoList = await fetch(`http://${inspectorURL.host}/json/list`).then((res)=>res.json());
                 debugInfo = debugInfoList[0];
             } catch  {}
             if (debugInfo) {
@@ -947,6 +947,7 @@ class HotReloaderWebpack {
         this.activeWebpackConfigs.parallelism = 1;
         await Promise.all(Array.from((0, _webpackconfig.getCacheDirectories)(this.activeWebpackConfigs)).map(_cacheinvalidation.checkFileSystemCacheInvalidationAndCleanup));
         this.multiCompiler = (0, _getwebpackbundler.default)()(this.activeWebpackConfigs);
+        await this.afterCompile(this.multiCompiler);
         // Copy over the filesystem so that it is shared between all compilers.
         const inputFileSystem = this.multiCompiler.compilers[0].inputFileSystem;
         for (const compiler of this.multiCompiler.compilers){
@@ -1199,55 +1200,46 @@ class HotReloaderWebpack {
             nextConfig: this.config,
             ...this.config.onDemandEntries
         });
-        this.middlewares = [
-            (0, _middlewarewebpack.getOverlayMiddleware)({
-                rootDirectory: this.dir,
-                isSrcDir: this.isSrcDir,
-                clientStats: ()=>this.clientStats,
-                serverStats: ()=>this.serverStats,
-                edgeServerStats: ()=>this.edgeServerStats
-            }),
-            (0, _middlewarewebpack.getSourceMapMiddleware)({
-                clientStats: ()=>this.clientStats,
-                serverStats: ()=>this.serverStats,
-                edgeServerStats: ()=>this.edgeServerStats
-            }),
-            (0, _getnexterrorfeedbackmiddleware.getNextErrorFeedbackMiddleware)(this.telemetry),
-            (0, _getdevoverlayfontmiddleware.getDevOverlayFontMiddleware)(),
-            (0, _devindicatormiddleware.getDisableDevIndicatorMiddleware)(),
-            (0, _restartdevservermiddleware.getRestartDevServerMiddleware)({
-                telemetry: this.telemetry,
-                webpackCacheDirectories: this.activeWebpackConfigs != null ? (0, _webpackconfig.getCacheDirectories)(this.activeWebpackConfigs) : undefined
-            }),
-            (0, _devtoolsconfigmiddleware.devToolsConfigMiddleware)({
+        this.middlewares.push((0, _middlewarewebpack.getOverlayMiddleware)({
+            rootDirectory: this.dir,
+            isSrcDir: this.isSrcDir,
+            clientStats: ()=>this.clientStats,
+            serverStats: ()=>this.serverStats,
+            edgeServerStats: ()=>this.edgeServerStats
+        }), (0, _middlewarewebpack.getSourceMapMiddleware)({
+            clientStats: ()=>this.clientStats,
+            serverStats: ()=>this.serverStats,
+            edgeServerStats: ()=>this.edgeServerStats
+        }), (0, _getnexterrorfeedbackmiddleware.getNextErrorFeedbackMiddleware)(this.telemetry), (0, _getdevoverlayfontmiddleware.getDevOverlayFontMiddleware)(), (0, _devindicatormiddleware.getDisableDevIndicatorMiddleware)(), (0, _restartdevservermiddleware.getRestartDevServerMiddleware)({
+            telemetry: this.telemetry,
+            webpackCacheDirectories: this.activeWebpackConfigs != null ? (0, _webpackconfig.getCacheDirectories)(this.activeWebpackConfigs) : undefined
+        }), (0, _devtoolsconfigmiddleware.devToolsConfigMiddleware)({
+            distDir: this.distDir,
+            sendUpdateSignal: (data)=>{
+                var // Update the in-memory devToolsConfig value
+                // which will be used for the next onHMR call.
+                _this_webpackHotMiddleware;
+                (_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.updateDevToolsConfig(data);
+                this.send({
+                    type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.DEVTOOLS_CONFIG,
+                    data
+                });
+            }
+        }), (0, _attachnodejsdebuggermiddleware.getAttachNodejsDebuggerMiddleware)(), ...this.config.experimental.mcpServer ? [
+            (0, _getmcpmiddleware.getMcpMiddleware)({
+                projectPath: this.dir,
                 distDir: this.distDir,
-                sendUpdateSignal: (data)=>{
-                    var // Update the in-memory devToolsConfig value
-                    // which will be used for the next onHMR call.
-                    _this_webpackHotMiddleware;
-                    (_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.updateDevToolsConfig(data);
-                    this.send({
-                        type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.DEVTOOLS_CONFIG,
-                        data
-                    });
-                }
-            }),
-            ...this.config.experimental.mcpServer ? [
-                (0, _getmcpmiddleware.getMcpMiddleware)({
-                    projectPath: this.dir,
-                    distDir: this.distDir,
-                    nextConfig: this.config,
-                    pagesDir: this.pagesDir,
-                    appDir: this.appDir,
-                    sendHmrMessage: (message)=>this.send(message),
-                    getActiveConnectionCount: ()=>{
-                        var _this_webpackHotMiddleware;
-                        return ((_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.getClientCount()) ?? 0;
-                    },
-                    getDevServerUrl: ()=>process.env.__NEXT_PRIVATE_ORIGIN
-                })
-            ] : []
-        ];
+                nextConfig: this.config,
+                pagesDir: this.pagesDir,
+                appDir: this.appDir,
+                sendHmrMessage: (message)=>this.send(message),
+                getActiveConnectionCount: ()=>{
+                    var _this_webpackHotMiddleware;
+                    return ((_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.getClientCount()) ?? 0;
+                },
+                getDevServerUrl: ()=>process.env.__NEXT_PRIVATE_ORIGIN
+            })
+        ] : []);
         (0, _formaterrors.setStackFrameResolver)(async (request)=>{
             return (0, _middlewarewebpack.getOriginalStackFrames)({
                 isServer: request.isServer,
@@ -1261,6 +1253,7 @@ class HotReloaderWebpack {
             });
         });
     }
+    async afterCompile(_multiCompiler) {}
     invalidate({ reloadAfterInvalidation } = {
         reloadAfterInvalidation: false
     }) {
@@ -1344,6 +1337,18 @@ class HotReloaderWebpack {
             (0, _debugchannel.connectReactDebugChannel)(requestId, debugChannel, this.sendToClient.bind(this, client));
         }
     }
+    sendErrorsToBrowser(errorsRscStream, htmlRequestId) {
+        var _this_webpackHotMiddleware;
+        const client = (_this_webpackHotMiddleware = this.webpackHotMiddleware) == null ? void 0 : _this_webpackHotMiddleware.getClient(htmlRequestId);
+        if (client) {
+            // If the client is connected, we can send the errors immediately.
+            (0, _serializederrors.sendSerializedErrorsToClient)(errorsRscStream, this.sendToClient.bind(this, client));
+        } else {
+            // Otherwise, store the errors stream so that we can send it when the
+            // client connects.
+            (0, _serializederrors.setErrorsRscStreamForHtmlRequest)(htmlRequestId, errorsRscStream);
+        }
+    }
     async ensurePage({ page, clientOnly, appPaths, definition, isApp, url }) {
         return this.hotReloaderSpan.traceChild('ensure-page', {
             inputPage: page

qalita/_frontend/node_modules/next/dist/server/dev/log-requests.js

@@ -39,9 +39,9 @@ function ignoreLoggingIncomingRequests(request, loggingConfig) {
     // If array of RegExp, ignore if any pattern matches
     return ignore.some((pattern)=>pattern.test(request.url));
 }
-function logRequests(request, response, loggingConfig, requestStartTime, requestEndTime, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd) {
+function logRequests(request, response, loggingConfig, requestStartTime, requestEndTime, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration) {
     if (!ignoreLoggingIncomingRequests(request, loggingConfig)) {
-        logIncomingRequests(request, requestStartTime, requestEndTime, response.statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd);
+        logIncomingRequests(request, requestStartTime, requestEndTime, response.statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration);
     }
     if (request.fetchMetrics) {
         for (const fetchMetric of request.fetchMetrics){
@@ -49,7 +49,7 @@ function logRequests(request, response, loggingConfig, requestStartTime, request
         }
     }
 }
-function logIncomingRequests(request, requestStartTime, requestEndTime, statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd) {
+function logIncomingRequests(request, requestStartTime, requestEndTime, statusCode, devRequestTimingMiddlewareStart, devRequestTimingMiddlewareEnd, devRequestTimingInternalsEnd, devGenerateStaticParamsDuration) {
     const isRSC = (0, _requestmeta.getRequestMeta)(request, 'isRSCRequest');
     const url = isRSC ? (0, _url.stripNextRscUnionQuery)(request.url) : request.url;
     const statusCodeColor = statusCode < 200 ? _picocolors.white : statusCode < 300 ? _picocolors.green : statusCode < 400 ? _picocolors.blue : statusCode < 500 ? _picocolors.yellow : _picocolors.red;
@@ -74,6 +74,14 @@ function logIncomingRequests(request, requestStartTime, requestEndTime, statusCo
             'compile',
             frameworkTime
         ]);
+        // Insert after compile, before render based on the execution order.
+        if (devGenerateStaticParamsDuration) {
+            // Pages Router getStaticPaths are technically "generate params" as well.
+            times.push([
+                'generate-params',
+                devGenerateStaticParamsDuration
+            ]);
+        }
         times.push([
             'render',
             requestEndTime - devRequestTimingInternalsEnd

qalita/_frontend/node_modules/next/dist/server/dev/messages.js

@@ -26,6 +26,16 @@ const FAST_REFRESH_RUNTIME_RELOAD = 'Fast Refresh had to perform a full reload d
 const textEncoder = new TextEncoder();
 function createBinaryHmrMessageData(message) {
     switch(message.type){
+        case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ERRORS_TO_SHOW_IN_BROWSER:
+            {
+                const { serializedErrors } = message;
+                const totalLength = 1 + serializedErrors.length;
+                const data = new Uint8Array(totalLength);
+                const view = new DataView(data.buffer);
+                view.setUint8(0, _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ERRORS_TO_SHOW_IN_BROWSER);
+                data.set(serializedErrors, 1);
+                return data;
+            }
         case _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.REACT_DEBUG_CHUNK:
             {
                 const { requestId, chunk } = message;

qalita/_frontend/node_modules/next/dist/server/dev/serialized-errors.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    deleteErrorsRscStreamForHtmlRequest: null,
+    sendSerializedErrorsToClient: null,
+    sendSerializedErrorsToClientForHtmlRequest: null,
+    setErrorsRscStreamForHtmlRequest: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    deleteErrorsRscStreamForHtmlRequest: function() {
+        return deleteErrorsRscStreamForHtmlRequest;
+    },
+    sendSerializedErrorsToClient: function() {
+        return sendSerializedErrorsToClient;
+    },
+    sendSerializedErrorsToClientForHtmlRequest: function() {
+        return sendSerializedErrorsToClientForHtmlRequest;
+    },
+    setErrorsRscStreamForHtmlRequest: function() {
+        return setErrorsRscStreamForHtmlRequest;
+    }
+});
+const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
+const _hotreloadertypes = require("./hot-reloader-types");
+const errorsRscStreamsByHtmlRequestId = new Map();
+function sendSerializedErrorsToClient(errorsRscStream, sendToClient) {
+    (0, _nodewebstreamshelper.streamToUint8Array)(errorsRscStream).then((serializedErrors)=>{
+        sendToClient({
+            type: _hotreloadertypes.HMR_MESSAGE_SENT_TO_BROWSER.ERRORS_TO_SHOW_IN_BROWSER,
+            serializedErrors
+        });
+    }, (err)=>{
+        console.error(Object.defineProperty(new Error('Failed to serialize errors.', {
+            cause: err
+        }), "__NEXT_ERROR_CODE", {
+            value: "E948",
+            enumerable: false,
+            configurable: true
+        }));
+    });
+}
+function sendSerializedErrorsToClientForHtmlRequest(htmlRequestId, sendToClient) {
+    const errorsRscStream = errorsRscStreamsByHtmlRequestId.get(htmlRequestId);
+    if (!errorsRscStream) {
+        return;
+    }
+    errorsRscStreamsByHtmlRequestId.delete(htmlRequestId);
+    sendSerializedErrorsToClient(errorsRscStream, sendToClient);
+}
+function setErrorsRscStreamForHtmlRequest(htmlRequestId, errorsRscStream) {
+    // TODO: Clean up after a timeout, in case the client never connects, e.g.
+    // when CURL'ing the page, or loading the page with JavaScript disabled etc.
+    errorsRscStreamsByHtmlRequestId.set(htmlRequestId, errorsRscStream);
+}
+function deleteErrorsRscStreamForHtmlRequest(htmlRequestId) {
+    errorsRscStreamsByHtmlRequestId.delete(htmlRequestId);
+}
+
+//# sourceMappingURL=serialized-errors.js.map

qalita/_frontend/node_modules/next/dist/server/dev/static-paths-worker.js

@@ -20,6 +20,7 @@ const _collectrootparamkeys = require("../../build/segment-config/app/collect-ro
 const _app = require("../../build/static-paths/app");
 const _pages = require("../../build/static-paths/pages");
 const _createincrementalcache = require("../../export/helpers/create-incremental-cache");
+const _app1 = require("../../shared/lib/router/routes/app");
 async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOptions, locales, defaultLocale, isAppPath, page, isrFlushToDisk, fetchCacheKeyPrefix, cacheMaxMemorySize, requestHeaders, cacheHandler, cacheHandlers, cacheLifeProfiles, nextConfigOutput, buildId, authInterrupts, sriEnabled }) {
     // this needs to be initialized before loadComponents otherwise
     // "use cache" could be missing it's cache handlers
@@ -51,11 +52,20 @@ async function loadStaticPaths({ dir, distDir, pathname, config, httpAgentOption
         const segments = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we checked
         // above that the page type is 'app'.
         routeModule);
+        const route = (0, _app1.parseAppRoute)(pathname, true);
+        if (route.dynamicSegments.length === 0) {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Expected a dynamic route, but got a static route: ${pathname}`), "__NEXT_ERROR_CODE", {
+                value: "E930",
+                enumerable: false,
+                configurable: true
+            });
+        }
         const isRoutePPREnabled = (0, _checks.isAppPageRouteModule)(routeModule) && (0, _ppr.checkIsRoutePPREnabled)(config.pprConfig);
         const rootParamKeys = (0, _collectrootparamkeys.collectRootParamKeys)(routeModule);
         return (0, _app.buildAppStaticPaths)({
             dir,
             page: pathname,
+            route,
             cacheComponents: config.cacheComponents,
             segments,
             distDir,

qalita/_frontend/node_modules/next/dist/server/lib/app-info-log.js

@@ -91,7 +91,7 @@ function logStartInfo({ networkUrl, appUrl, envInfo, experimentalFeatures, logBu
     if (parts.length > 0) {
         versionSuffix = ` (${parts.join(', ')})`;
     }
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.0.10"}`))}${versionSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.1.1"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }

qalita/_frontend/node_modules/next/dist/server/lib/chrome-devtools-workspace.js

@@ -67,8 +67,8 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 // Keep the uuid in memory as it should never change during the lifetime of the server.
 let workspaceUUID = null;
-function isChromeDevtoolsWorkspaceUrl(url) {
-    return url.pathname === '/.well-known/appspecific/com.chrome.devtools.json';
+function isChromeDevtoolsWorkspaceUrl(pathname) {
+    return pathname === '/.well-known/appspecific/com.chrome.devtools.json';
 }
 async function handleChromeDevtoolsWorkspaceRequest(response, opts, config) {
     response.setHeader('Content-Type', 'application/json');

qalita/_frontend/node_modules/next/dist/server/lib/dev-bundler-service.js

@@ -23,6 +23,11 @@ class DevBundlerService {
         this.appIsrManifestInner = new _lrucache.LRUCache(8000, function length() {
             return 16;
         });
+        const { hotReloader } = bundler;
+        this.close = hotReloader.close.bind(hotReloader);
+        this.setCacheStatus = hotReloader.setCacheStatus.bind(hotReloader);
+        this.setReactDebugChannel = hotReloader.setReactDebugChannel.bind(hotReloader);
+        this.sendErrorsToBrowser = hotReloader.sendErrorsToBrowser.bind(hotReloader);
     }
     async getFallbackErrorComponents(url) {
         await this.bundler.hotReloader.buildFallbackError();
@@ -64,9 +69,6 @@ class DevBundlerService {
         }
         return serializableManifest;
     }
-    setCacheStatus(status, htmlRequestId) {
-        this.bundler.hotReloader.setCacheStatus(status, htmlRequestId);
-    }
     setIsrStatus(key, value) {
         var // Only send the ISR manifest to legacy clients, i.e. Pages Router clients,
         // or App Router clients that have Cache Components disabled. The ISR
@@ -85,13 +87,7 @@ class DevBundlerService {
             data: this.appIsrManifest
         });
     }
-    setReactDebugChannel(debugChannel, htmlRequestId, requestId) {
-        this.bundler.hotReloader.setReactDebugChannel(debugChannel, htmlRequestId, requestId);
-    }
-    close() {
-        this.bundler.hotReloader.close();
-    }
-    triggerHMR(message) {
+    sendHmrMessage(message) {
         this.bundler.hotReloader.send(message);
     }
 }

qalita/_frontend/node_modules/next/dist/server/lib/incremental-cache/file-system-cache.js

@@ -164,8 +164,8 @@ class FileSystemCache {
                             }));
                         }
                         let rscData;
-                        if (!ctx.isFallback) {
-                            rscData = await this.fs.readFile(this.getFilePath(`${key}${ctx.isRoutePPREnabled ? _constants.RSC_PREFETCH_SUFFIX : _constants.RSC_SUFFIX}`, _responsecache.IncrementalCacheKind.APP_PAGE));
+                        if (!ctx.isFallback && !ctx.isRoutePPREnabled) {
+                            rscData = await this.fs.readFile(this.getFilePath(`${key}${_constants.RSC_SUFFIX}`, _responsecache.IncrementalCacheKind.APP_PAGE));
                         }
                         data = {
                             lastModified: mtime.getTime(),
@@ -276,8 +276,8 @@ class FileSystemCache {
             const htmlPath = this.getFilePath(`${key}.html`, isAppPath ? _responsecache.IncrementalCacheKind.APP_PAGE : _responsecache.IncrementalCacheKind.PAGES);
             writer.append(htmlPath, data.html);
             // Fallbacks don't generate a data file.
-            if (!ctx.fetchCache && !ctx.isFallback) {
-                writer.append(this.getFilePath(`${key}${isAppPath ? ctx.isRoutePPREnabled ? _constants.RSC_PREFETCH_SUFFIX : _constants.RSC_SUFFIX : _constants.NEXT_DATA_SUFFIX}`, isAppPath ? _responsecache.IncrementalCacheKind.APP_PAGE : _responsecache.IncrementalCacheKind.PAGES), isAppPath ? data.rscData : JSON.stringify(data.pageData));
+            if (!ctx.fetchCache && !ctx.isFallback && !ctx.isRoutePPREnabled) {
+                writer.append(this.getFilePath(`${key}${isAppPath ? _constants.RSC_SUFFIX : _constants.NEXT_DATA_SUFFIX}`, isAppPath ? _responsecache.IncrementalCacheKind.APP_PAGE : _responsecache.IncrementalCacheKind.PAGES), isAppPath ? data.rscData : JSON.stringify(data.pageData));
             }
             if ((data == null ? void 0 : data.kind) === _responsecache.CachedRouteKind.APP_PAGE) {
                 let segmentPaths;

qalita/_frontend/node_modules/next/dist/server/lib/lazy-result.js

@@ -25,7 +25,7 @@ function createLazyResult(fn) {
     const result = {
         then (onfulfilled, onrejected) {
             if (!pendingResult) {
-                pendingResult = fn();
+                pendingResult = Promise.resolve(fn());
             }
             pendingResult.then((value)=>{
                 result.value = value;

qalita/_frontend/node_modules/next/dist/server/lib/patch-fetch.js

@@ -166,20 +166,20 @@ async function createCachedDynamicResponse(workStore, res, cacheKey, incremental
         }
     }).catch((error)=>console.warn(`Failed to set fetch cache`, input, error)).finally(handleUnlock);
     const pendingRevalidateKey = `cache-set-${cacheKey}`;
-    workStore.pendingRevalidates ??= {};
-    if (pendingRevalidateKey in workStore.pendingRevalidates) {
-        // there is already a pending revalidate entry that we need to await to
-        // avoid race conditions
-        await workStore.pendingRevalidates[pendingRevalidateKey];
+    const pendingRevalidates = workStore.pendingRevalidates ??= {};
+    let pendingRevalidatePromise = Promise.resolve();
+    if (pendingRevalidateKey in pendingRevalidates) {
+        // There is already a pending revalidate entry that we need to await to
+        // avoid race conditions.
+        pendingRevalidatePromise = pendingRevalidates[pendingRevalidateKey];
     }
-    workStore.pendingRevalidates[pendingRevalidateKey] = cacheSetPromise.finally(()=>{
-        var _workStore_pendingRevalidates;
+    pendingRevalidates[pendingRevalidateKey] = pendingRevalidatePromise.then(()=>cacheSetPromise).finally(()=>{
         // If the pending revalidate is not present in the store, then we have
         // nothing to delete.
-        if (!((_workStore_pendingRevalidates = workStore.pendingRevalidates) == null ? void 0 : _workStore_pendingRevalidates[pendingRevalidateKey])) {
+        if (!(pendingRevalidates == null ? void 0 : pendingRevalidates[pendingRevalidateKey])) {
             return;
         }
-        delete workStore.pendingRevalidates[pendingRevalidateKey];
+        delete pendingRevalidates[pendingRevalidateKey];
     });
     return cloned2;
 }