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

qalita/_frontend/node_modules/next/dist/server/app-render/collect-segment-data.js

@@ -15,6 +15,8 @@ const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper")
 const _scheduler = require("../../lib/scheduler");
 const _segmentvalueencoding = require("../../shared/lib/segment-cache/segment-value-encoding");
 const _createerrorhandler = require("./create-error-handler");
+const _prospectiverenderutils = require("./prospective-render-utils");
+const _workasyncstorageexternal = require("./work-async-storage.external");
 const filterStackFrame = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').filterStackFrameDEV : undefined;
 const findSourceMapURL = process.env.NODE_ENV !== 'production' ? require('../lib/source-maps').findSourceMapURLDEV : undefined;
 function onSegmentPrerenderError(error) {
@@ -22,8 +24,12 @@ function onSegmentPrerenderError(error) {
     if (digest) {
         return digest;
     }
-// We don't need to log the errors because we would have already done that
-// when generating the original Flight stream for the whole page.
+    // We don't need to log the errors because we would have already done that
+    // when generating the original Flight stream for the whole page.
+    if (process.env.NEXT_DEBUG_BUILD || process.env.__NEXT_VERBOSE_LOGGING) {
+        const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+        (0, _prospectiverenderutils.printDebugThrownValueForProspectiveRender)(error, (workStore == null ? void 0 : workStore.route) ?? 'unknown route', _prospectiverenderutils.Phase.SegmentCollection);
+    }
 }
 async function collectSegmentData(isCacheComponentsEnabled, fullPageDataBuffer, staleTime, clientModules, serverConsumerManifest) {
     // Traverse the router tree and generate a prefetch response for each segment.

qalita/_frontend/node_modules/next/dist/server/app-render/create-component-styles-and-scripts.js

@@ -15,7 +15,7 @@ const _encodeuripath = require("../../shared/lib/encode-uri-path");
 const _rendercssresource = require("./render-css-resource");
 async function createComponentStylesAndScripts({ filePath, getComponent, injectedCSS, injectedJS, ctx }) {
     const { componentMod: { createElement } } = ctx;
-    const { styles: entryCssFiles, scripts: jsHrefs } = (0, _getcssinlinedlinktags.getLinkAndScriptTags)(ctx.clientReferenceManifest, filePath, injectedCSS, injectedJS);
+    const { styles: entryCssFiles, scripts: jsHrefs } = (0, _getcssinlinedlinktags.getLinkAndScriptTags)(filePath, injectedCSS, injectedJS);
     const styles = (0, _rendercssresource.renderCssResource)(entryCssFiles, ctx);
     const scripts = jsHrefs ? jsHrefs.map((href, index)=>createElement('script', {
             src: `${ctx.assetPrefix}/_next/${(0, _encodeuripath.encodeURIPath)(href)}${(0, _getassetquerystring.getAssetQueryString)(ctx, true)}`,

qalita/_frontend/node_modules/next/dist/server/app-render/create-error-handler.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    createFlightReactServerErrorHandler: null,
     createHTMLErrorHandler: null,
-    createHTMLReactServerErrorHandler: null,
+    createReactServerErrorHandler: null,
     getDigestForWellKnownError: null,
     isUserLandError: null
 });
@@ -16,14 +15,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    createFlightReactServerErrorHandler: function() {
-        return createFlightReactServerErrorHandler;
-    },
     createHTMLErrorHandler: function() {
         return createHTMLErrorHandler;
     },
-    createHTMLReactServerErrorHandler: function() {
-        return createHTMLReactServerErrorHandler;
+    createReactServerErrorHandler: function() {
+        return createReactServerErrorHandler;
     },
     getDigestForWellKnownError: function() {
         return getDigestForWellKnownError;
@@ -62,49 +58,7 @@ function getDigestForWellKnownError(error) {
     if ((0, _dynamicrendering.isPrerenderInterruptedError)(error)) return error.digest;
     return undefined;
 }
-function createFlightReactServerErrorHandler(shouldFormatError, onReactServerRenderError) {
-    return (thrownValue)=>{
-        if (typeof thrownValue === 'string') {
-            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
-            return (0, _stringhash.default)(thrownValue).toString();
-        }
-        // If the response was closed, we don't need to log the error.
-        if ((0, _pipereadable.isAbortError)(thrownValue)) return;
-        const digest = getDigestForWellKnownError(thrownValue);
-        if (digest) {
-            return digest;
-        }
-        if ((0, _reactlargeshellerror.isReactLargeShellError)(thrownValue)) {
-            // TODO: Aggregate
-            console.error(thrownValue);
-            return undefined;
-        }
-        const err = (0, _iserror.getProperError)(thrownValue);
-        // If the error already has a digest, respect the original digest,
-        // so it won't get re-generated into another new error.
-        if (!err.digest) {
-            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
-            err.digest = (0, _stringhash.default)(err.message + err.stack || '').toString();
-        }
-        // Format server errors in development to add more helpful error messages
-        if (shouldFormatError) {
-            (0, _formatservererror.formatServerError)(err);
-        }
-        // Record exception in an active span, if available.
-        const span = (0, _tracer.getTracer)().getActiveScopeSpan();
-        if (span) {
-            span.recordException(err);
-            span.setAttribute('error.type', err.name);
-            span.setStatus({
-                code: _tracer.SpanStatusCode.ERROR,
-                message: err.message
-            });
-        }
-        onReactServerRenderError(err);
-        return (0, _errortelemetryutils.createDigestWithErrorCode)(thrownValue, err.digest);
-    };
-}
-function createHTMLReactServerErrorHandler(shouldFormatError, isNextExport, reactServerErrors, silenceLogger, onReactServerRenderError) {
+function createReactServerErrorHandler(shouldFormatError, isNextExport, reactServerErrors, onReactServerRenderError, spanToRecordOn) {
     return (thrownValue)=>{
         var _err_message;
         if (typeof thrownValue === 'string') {
@@ -122,12 +76,27 @@ function createHTMLReactServerErrorHandler(shouldFormatError, isNextExport, reac
             console.error(thrownValue);
             return undefined;
         }
-        const err = (0, _iserror.getProperError)(thrownValue);
+        let err = (0, _iserror.getProperError)(thrownValue);
+        let silenceLog = false;
         // If the error already has a digest, respect the original digest,
         // so it won't get re-generated into another new error.
-        if (!err.digest) {
-            // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
-            err.digest = (0, _stringhash.default)(err.message + (err.stack || '')).toString();
+        if (err.digest) {
+            if (process.env.NODE_ENV === 'production' && reactServerErrors.has(err.digest)) {
+                // This error is likely an obfuscated error from another react-server
+                // environment (e.g. 'use cache'). We recover the original error here
+                // for reporting purposes.
+                err = reactServerErrors.get(err.digest);
+                // We don't log it again though, as it was already logged in the
+                // original environment.
+                silenceLog = true;
+            } else {
+            // Either we're in development (where we want to keep the transported
+            // error with environmentName), or the error is not in reactServerErrors
+            // but has a digest from other means. Keep the error as-is.
+            }
+        } else {
+            err.digest = (0, _errortelemetryutils.createDigestWithErrorCode)(err, // TODO-APP: look at using webcrypto instead. Requires a promise to be awaited.
+            (0, _stringhash.default)(err.message + (err.stack || '')).toString());
         }
         // @TODO by putting this here and not at the top it is possible that
         // we don't error the build in places we actually expect to
@@ -140,8 +109,8 @@ function createHTMLReactServerErrorHandler(shouldFormatError, isNextExport, reac
         }
         // Don't log the suppressed error during export
         if (!(isNextExport && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
-            // Record exception in an active span, if available.
-            const span = (0, _tracer.getTracer)().getActiveScopeSpan();
+            // Record exception on the provided span if available, otherwise try active span.
+            const span = spanToRecordOn ?? (0, _tracer.getTracer)().getActiveScopeSpan();
             if (span) {
                 span.recordException(err);
                 span.setAttribute('error.type', err.name);
@@ -150,14 +119,12 @@ function createHTMLReactServerErrorHandler(shouldFormatError, isNextExport, reac
                     message: err.message
                 });
             }
-            if (!silenceLogger) {
-                onReactServerRenderError == null ? void 0 : onReactServerRenderError(err);
-            }
+            onReactServerRenderError(err, silenceLog);
         }
-        return (0, _errortelemetryutils.createDigestWithErrorCode)(thrownValue, err.digest);
+        return err.digest;
     };
 }
-function createHTMLErrorHandler(shouldFormatError, isNextExport, reactServerErrors, allCapturedErrors, silenceLogger, onHTMLRenderSSRError) {
+function createHTMLErrorHandler(shouldFormatError, isNextExport, reactServerErrors, allCapturedErrors, onHTMLRenderSSRError, spanToRecordOn) {
     return (thrownValue, errorInfo)=>{
         var _err_message;
         if ((0, _reactlargeshellerror.isReactLargeShellError)(thrownValue)) {
@@ -187,7 +154,7 @@ function createHTMLErrorHandler(shouldFormatError, isNextExport, reactServerErro
             // from other means so we don't need to produce a new one
             }
         } else {
-            err.digest = (0, _stringhash.default)(err.message + ((errorInfo == null ? void 0 : errorInfo.componentStack) || err.stack || '')).toString();
+            err.digest = (0, _errortelemetryutils.createDigestWithErrorCode)(err, (0, _stringhash.default)(err.message + ((errorInfo == null ? void 0 : errorInfo.componentStack) || err.stack || '')).toString());
         }
         // Format server errors in development to add more helpful error messages
         if (shouldFormatError) {
@@ -195,22 +162,22 @@ function createHTMLErrorHandler(shouldFormatError, isNextExport, reactServerErro
         }
         // Don't log the suppressed error during export
         if (!(isNextExport && (err == null ? void 0 : (_err_message = err.message) == null ? void 0 : _err_message.includes('The specific message is omitted in production builds to avoid leaking sensitive details.')))) {
-            // Record exception in an active span, if available.
-            const span = (0, _tracer.getTracer)().getActiveScopeSpan();
-            if (span) {
-                span.recordException(err);
-                span.setAttribute('error.type', err.name);
-                span.setStatus({
-                    code: _tracer.SpanStatusCode.ERROR,
-                    message: err.message
-                });
-            }
-            if (!silenceLogger && // HTML errors contain RSC errors as well, filter them out before reporting
-            isSSRError) {
+            // HTML errors contain RSC errors as well, filter them out before reporting
+            if (isSSRError) {
+                // Record exception on the provided span if available, otherwise try active span.
+                const span = spanToRecordOn ?? (0, _tracer.getTracer)().getActiveScopeSpan();
+                if (span) {
+                    span.recordException(err);
+                    span.setAttribute('error.type', err.name);
+                    span.setStatus({
+                        code: _tracer.SpanStatusCode.ERROR,
+                        message: err.message
+                    });
+                }
                 onHTMLRenderSSRError(err, errorInfo);
             }
         }
-        return (0, _errortelemetryutils.createDigestWithErrorCode)(thrownValue, err.digest);
+        return err.digest;
     };
 }
 function isUserLandError(err) {

qalita/_frontend/node_modules/next/dist/server/app-render/dynamic-rendering.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", {
     delayUntilRuntimeStage: null,
     formatDynamicAPIAccesses: null,
     getFirstDynamicReason: null,
+    getStaticShellDisallowedDynamicReasons: null,
     isDynamicPostpone: null,
     isPrerenderInterruptedError: null,
     logDisallowedDynamicError: null,
@@ -46,7 +47,8 @@ Object.defineProperty(exports, "__esModule", {
     throwToInterruptStaticGeneration: null,
     trackAllowedDynamicAccess: null,
     trackDynamicDataInDynamicRender: null,
-    trackSynchronousPlatformIOAccessInDev: null,
+    trackDynamicHoleInRuntimeShell: null,
+    trackDynamicHoleInStaticShell: null,
     useDynamicRouteParams: null,
     useDynamicSearchParams: null
 });
@@ -99,6 +101,9 @@ _export(exports, {
     getFirstDynamicReason: function() {
         return getFirstDynamicReason;
     },
+    getStaticShellDisallowedDynamicReasons: function() {
+        return getStaticShellDisallowedDynamicReasons;
+    },
     isDynamicPostpone: function() {
         return isDynamicPostpone;
     },
@@ -126,8 +131,11 @@ _export(exports, {
     trackDynamicDataInDynamicRender: function() {
         return trackDynamicDataInDynamicRender;
     },
-    trackSynchronousPlatformIOAccessInDev: function() {
-        return trackSynchronousPlatformIOAccessInDev;
+    trackDynamicHoleInRuntimeShell: function() {
+        return trackDynamicHoleInRuntimeShell;
+    },
+    trackDynamicHoleInStaticShell: function() {
+        return trackDynamicHoleInStaticShell;
     },
     useDynamicRouteParams: function() {
         return useDynamicRouteParams;
@@ -146,7 +154,6 @@ const _boundaryconstants = require("../../lib/framework/boundary-constants");
 const _scheduler = require("../../lib/scheduler");
 const _bailouttocsr = require("../../shared/lib/lazy-dynamic/bailout-to-csr");
 const _invarianterror = require("../../shared/lib/invariant-error");
-const _stagedrendering = require("./staged-rendering");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -164,6 +171,7 @@ function createDynamicValidationState() {
     return {
         hasSuspenseAboveBody: false,
         hasDynamicMetadata: false,
+        dynamicMetadata: null,
         hasDynamicViewport: false,
         hasAllowedDynamic: false,
         dynamicErrors: []
@@ -297,15 +305,6 @@ function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, p
         }
     }
 }
-function trackSynchronousPlatformIOAccessInDev(requestStore) {
-    // We don't actually have a controller to abort but we do the semantic equivalent by
-    // advancing the request store out of the prerender stage
-    if (requestStore.stagedRendering) {
-        // TODO: error for sync IO in the runtime stage
-        // (which is not currently covered by the validation render in `spawnDynamicValidationInDev`)
-        requestStore.stagedRendering.advanceStage(_stagedrendering.RenderStage.Dynamic);
-    }
-}
 function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
     const prerenderSignal = prerenderStore.controller.signal;
     if (prerenderSignal.aborted === false) {
@@ -630,6 +629,80 @@ function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation,
         return;
     }
 }
+function trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
+    if (hasOutletRegex.test(componentStack)) {
+        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
+        return;
+    } else if (hasMetadataRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateMetadata\`. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicMetadata = error;
+        return;
+    } else if (hasViewportRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        return;
+    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
+        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
+        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
+        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
+        dynamicValidation.hasAllowedDynamic = true;
+        dynamicValidation.hasSuspenseAboveBody = true;
+        return;
+    } else if (hasSuspenseRegex.test(componentStack)) {
+        // this error had a Suspense boundary above it so we don't need to report it as a source
+        // of disallowed
+        dynamicValidation.hasAllowedDynamic = true;
+        return;
+    } else if (clientDynamic.syncDynamicErrorWithStack) {
+        // This task was the task that called the sync error.
+        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
+        return;
+    } else {
+        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        return;
+    }
+}
+function trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidation, clientDynamic) {
+    if (hasOutletRegex.test(componentStack)) {
+        // We don't need to track that this is dynamic. It is only so when something else is also dynamic.
+        return;
+    } else if (hasMetadataRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicMetadata = error;
+        return;
+    } else if (hasViewportRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        return;
+    } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
+        // For Suspense within body, the prelude wouldn't be empty so it wouldn't violate the empty static shells rule.
+        // But if you have Suspense above body, the prelude is empty but we allow that because having Suspense
+        // is an explicit signal from the user that they acknowledge the empty shell and want dynamic rendering.
+        dynamicValidation.hasAllowedDynamic = true;
+        dynamicValidation.hasSuspenseAboveBody = true;
+        return;
+    } else if (hasSuspenseRegex.test(componentStack)) {
+        // this error had a Suspense boundary above it so we don't need to report it as a source
+        // of disallowed
+        dynamicValidation.hasAllowedDynamic = true;
+        return;
+    } else if (clientDynamic.syncDynamicErrorWithStack) {
+        // This task was the task that called the sync error.
+        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
+        return;
+    } else {
+        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed outside of \`<Suspense>\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        return;
+    }
+}
 /**
  * In dev mode, we prefer using the owner stack, otherwise the provided
  * component stack is used.
@@ -640,7 +713,9 @@ function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation,
         enumerable: false,
         configurable: true
     });
-    error.stack = error.name + ': ' + message + (ownerStack ?? componentStack);
+    // TODO go back to owner stack here if available. This is temporarily using componentStack to get the right
+    //
+    error.stack = error.name + ': ' + message + (ownerStack || componentStack);
     return error;
 }
 var PreludeState = /*#__PURE__*/ function(PreludeState) {
@@ -705,6 +780,44 @@ function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverD
         }
     }
 }
+function getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation) {
+    if (dynamicValidation.hasSuspenseAboveBody) {
+        // This route has opted into allowing fully dynamic rendering
+        // by including a Suspense boundary above the body. In this case
+        // a lack of a shell is not considered disallowed so we simply return
+        return [];
+    }
+    if (prelude !== 0) {
+        // We didn't have any sync bailouts but there may be user code which
+        // blocked the root. We would have captured these during the prerender
+        // and can log them here and then terminate the build/validating render
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        if (dynamicErrors.length > 0) {
+            return dynamicErrors;
+        }
+        if (prelude === 1) {
+            // If we ever get this far then we messed up the tracking of invalid dynamic.
+            // We still adhere to the constraint that you must produce a shell but invite the
+            // user to report this as a bug in Next.js.
+            return [
+                Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
+                    value: "E936",
+                    enumerable: false,
+                    configurable: true
+                })
+            ];
+        }
+    } else {
+        // We have a prelude but we might still have dynamic metadata without any other dynamic access
+        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicErrors.length === 0 && dynamicValidation.dynamicMetadata) {
+            return [
+                dynamicValidation.dynamicMetadata
+            ];
+        }
+    }
+    // We had a non-empty prelude and there are no dynamic holes
+    return [];
+}
 function delayUntilRuntimeStage(prerenderStore, result) {
     if (prerenderStore.runtimeStagePromise) {
         return prerenderStore.runtimeStagePromise.then(()=>result);

qalita/_frontend/node_modules/next/dist/server/app-render/encryption-utils.js

@@ -7,9 +7,6 @@ Object.defineProperty(exports, "__esModule", {
     decrypt: null,
     encrypt: null,
     getActionEncryptionKey: null,
-    getClientReferenceManifestForRsc: null,
-    getServerModuleMap: null,
-    setReferenceManifestsSingleton: null,
     stringToUint8Array: null
 });
 function _export(target, all) {
@@ -31,22 +28,12 @@ _export(exports, {
     getActionEncryptionKey: function() {
         return getActionEncryptionKey;
     },
-    getClientReferenceManifestForRsc: function() {
-        return getClientReferenceManifestForRsc;
-    },
-    getServerModuleMap: function() {
-        return getServerModuleMap;
-    },
-    setReferenceManifestsSingleton: function() {
-        return setReferenceManifestsSingleton;
-    },
     stringToUint8Array: function() {
         return stringToUint8Array;
     }
 });
 const _invarianterror = require("../../shared/lib/invariant-error");
-const _apppaths = require("../../shared/lib/router/utils/app-paths");
-const _workasyncstorageexternal = require("./work-async-storage.external");
+const _manifestssingleton = require("./manifests-singleton");
 let __next_loaded_action_key;
 function arrayBufferToString(buffer) {
     const bytes = new Uint8Array(buffer);
@@ -83,81 +70,12 @@ function decrypt(key, iv, data) {
         iv
     }, key, data);
 }
-// This is a global singleton that is used to encode/decode the action bound args from
-// the closure. This can't be using a AsyncLocalStorage as it might happen on the module
-// level. Since the client reference manifest won't be mutated, let's use a global singleton
-// to keep it.
-const SERVER_ACTION_MANIFESTS_SINGLETON = Symbol.for('next.server.action-manifests');
-function setReferenceManifestsSingleton({ page, clientReferenceManifest, serverActionsManifest, serverModuleMap }) {
-    var _globalThis_SERVER_ACTION_MANIFESTS_SINGLETON;
-    // @ts-expect-error
-    const clientReferenceManifestsPerPage = (_globalThis_SERVER_ACTION_MANIFESTS_SINGLETON = globalThis[SERVER_ACTION_MANIFESTS_SINGLETON]) == null ? void 0 : _globalThis_SERVER_ACTION_MANIFESTS_SINGLETON.clientReferenceManifestsPerPage;
-    // @ts-expect-error
-    globalThis[SERVER_ACTION_MANIFESTS_SINGLETON] = {
-        clientReferenceManifestsPerPage: {
-            ...clientReferenceManifestsPerPage,
-            [(0, _apppaths.normalizeAppPath)(page)]: clientReferenceManifest
-        },
-        serverActionsManifest,
-        serverModuleMap
-    };
-}
-function getServerModuleMap() {
-    const serverActionsManifestSingleton = globalThis[SERVER_ACTION_MANIFESTS_SINGLETON];
-    if (!serverActionsManifestSingleton) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Missing manifest for Server Actions.'), "__NEXT_ERROR_CODE", {
-            value: "E606",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    return serverActionsManifestSingleton.serverModuleMap;
-}
-function getClientReferenceManifestForRsc() {
-    const serverActionsManifestSingleton = globalThis[SERVER_ACTION_MANIFESTS_SINGLETON];
-    if (!serverActionsManifestSingleton) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Missing manifest for Server Actions.'), "__NEXT_ERROR_CODE", {
-            value: "E606",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const { clientReferenceManifestsPerPage } = serverActionsManifestSingleton;
-    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
-    if (!workStore) {
-        // If there's no work store defined, we can assume that a client reference
-        // manifest is needed during module evaluation, e.g. to create a server
-        // action using a higher-order function. This might also use client
-        // components which need to be serialized by Flight, and therefore client
-        // references need to be resolvable. To make this work, we're returning a
-        // merged manifest across all pages. This is fine as long as the module IDs
-        // are not page specific, which they are not for Webpack. TODO: Fix this in
-        // Turbopack.
-        return mergeClientReferenceManifests(clientReferenceManifestsPerPage);
-    }
-    const clientReferenceManifest = clientReferenceManifestsPerPage[workStore.route];
-    if (!clientReferenceManifest) {
-        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing Client Reference Manifest for ${workStore.route}.`), "__NEXT_ERROR_CODE", {
-            value: "E570",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    return clientReferenceManifest;
-}
 async function getActionEncryptionKey() {
     if (__next_loaded_action_key) {
         return __next_loaded_action_key;
     }
-    const serverActionsManifestSingleton = globalThis[SERVER_ACTION_MANIFESTS_SINGLETON];
-    if (!serverActionsManifestSingleton) {
-        throw Object.defineProperty(new _invarianterror.InvariantError('Missing manifest for Server Actions.'), "__NEXT_ERROR_CODE", {
-            value: "E606",
-            enumerable: false,
-            configurable: true
-        });
-    }
-    const rawKey = process.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY || serverActionsManifestSingleton.serverActionsManifest.encryptionKey;
+    const serverActionsManifest = (0, _manifestssingleton.getServerActionsManifest)();
+    const rawKey = process.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY || serverActionsManifest.encryptionKey;
     if (rawKey === undefined) {
         throw Object.defineProperty(new _invarianterror.InvariantError('Missing encryption key for Server Actions'), "__NEXT_ERROR_CODE", {
             value: "E571",
@@ -171,28 +89,5 @@ async function getActionEncryptionKey() {
     ]);
     return __next_loaded_action_key;
 }
-function mergeClientReferenceManifests(clientReferenceManifestsPerPage) {
-    const clientReferenceManifests = Object.values(clientReferenceManifestsPerPage);
-    const mergedClientReferenceManifest = {
-        clientModules: {},
-        edgeRscModuleMapping: {},
-        rscModuleMapping: {}
-    };
-    for (const clientReferenceManifest of clientReferenceManifests){
-        mergedClientReferenceManifest.clientModules = {
-            ...mergedClientReferenceManifest.clientModules,
-            ...clientReferenceManifest.clientModules
-        };
-        mergedClientReferenceManifest.edgeRscModuleMapping = {
-            ...mergedClientReferenceManifest.edgeRscModuleMapping,
-            ...clientReferenceManifest.edgeRscModuleMapping
-        };
-        mergedClientReferenceManifest.rscModuleMapping = {
-            ...mergedClientReferenceManifest.rscModuleMapping,
-            ...clientReferenceManifest.rscModuleMapping
-        };
-    }
-    return mergedClientReferenceManifest;
-}
 
 //# sourceMappingURL=encryption-utils.js.map

qalita/_frontend/node_modules/next/dist/server/app-render/encryption.js

@@ -25,6 +25,7 @@ const _server = require("react-server-dom-webpack/server");
 const _client = require("react-server-dom-webpack/client");
 const _nodewebstreamshelper = require("../stream-utils/node-web-streams-helper");
 const _encryptionutils = require("./encryption-utils");
+const _manifestssingleton = require("./manifests-singleton");
 const _workunitasyncstorageexternal = require("./work-unit-async-storage.external");
 const _dynamicrendering = require("./dynamic-rendering");
 const _react = /*#__PURE__*/ _interop_require_default(require("react"));
@@ -91,7 +92,7 @@ var ReadStatus = /*#__PURE__*/ function(ReadStatus) {
 const encryptActionBoundArgs = _react.default.cache(async function encryptActionBoundArgs(actionId, ...args) {
     const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
     const cacheSignal = workUnitStore ? (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore) : undefined;
-    const { clientModules } = (0, _encryptionutils.getClientReferenceManifestForRsc)();
+    const { clientModules } = (0, _manifestssingleton.getClientReferenceManifest)();
     // Create an error before any asynchronous calls, to capture the original
     // call stack in case we need it when the serialization errors.
     const error = new Error();
@@ -189,7 +190,7 @@ async function decryptActionBoundArgs(actionId, encryptedPromise) {
     } else {
         decrypted = await decodeActionBoundArg(actionId, encrypted);
     }
-    const { edgeRscModuleMapping, rscModuleMapping } = (0, _encryptionutils.getClientReferenceManifestForRsc)();
+    const { edgeRscModuleMapping, rscModuleMapping } = (0, _manifestssingleton.getClientReferenceManifest)();
     // Using Flight to deserialize the args from the string.
     const deserialized = await (0, _client.createFromReadableStream)(new ReadableStream({
         start (controller) {
@@ -228,7 +229,7 @@ async function decryptActionBoundArgs(actionId, encryptedPromise) {
             // to be emitted which themselves will handle the preloading.
             moduleLoading: null,
             moduleMap: isEdgeRuntime ? edgeRscModuleMapping : rscModuleMapping,
-            serverModuleMap: (0, _encryptionutils.getServerModuleMap)()
+            serverModuleMap: (0, _manifestssingleton.getServerModuleMap)()
         }
     });
     return deserialized;

qalita/_frontend/node_modules/next/dist/server/app-render/flight-render-result.js

@@ -16,10 +16,11 @@ function _interop_require_default(obj) {
     };
 }
 class FlightRenderResult extends _renderresult.default {
-    constructor(response, metadata = {}){
+    constructor(response, metadata = {}, waitUntil){
         super(response, {
             contentType: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
-            metadata
+            metadata,
+            waitUntil
         });
     }
 }