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

qalita/_frontend/node_modules/next/dist/lib/typescript/type-paths.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getDevTypesPath: null,
+    getTypeDefinitionGlobPatterns: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getDevTypesPath: function() {
+        return getDevTypesPath;
+    },
+    getTypeDefinitionGlobPatterns: function() {
+        return getTypeDefinitionGlobPatterns;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getTypeDefinitionGlobPatterns(distDir, isolatedDevBuild) {
+    const distDirPosix = _path.default.win32.sep === _path.default.sep ? distDir.replaceAll(_path.default.win32.sep, _path.default.posix.sep) : distDir;
+    const typeGlobPatterns = [
+        `${distDirPosix}/types/**/*.ts`
+    ];
+    // When isolatedDevBuild is enabled, include both .next/types and .next/dev/types
+    // to avoid tsconfig churn when switching between dev/build modes
+    if (isolatedDevBuild) {
+        typeGlobPatterns.push(process.env.NODE_ENV === 'development' ? `${distDirPosix.replace(/\/dev$/, '')}/types/**/*.ts` : `${distDirPosix}/dev/types/**/*.ts`);
+        // Sort for consistent order
+        typeGlobPatterns.sort((a, b)=>a.length - b.length);
+    }
+    return typeGlobPatterns;
+}
+function getDevTypesPath(baseDir, distDir, isolatedDevBuild) {
+    if (!isolatedDevBuild) {
+        return null;
+    }
+    const isDev = process.env.NODE_ENV === 'development';
+    if (isDev) {
+        // In dev mode, dev types are the main types, so no need to filter
+        return null;
+    }
+    // In build mode, dev types are at "{baseDir}/{distDir}/dev/types" and should be filtered
+    return _path.default.join(baseDir, distDir, 'dev', 'types');
+}
+
+//# sourceMappingURL=type-paths.js.map

qalita/_frontend/node_modules/next/dist/lib/typescript/writeConfigurationDefaults.js

@@ -21,12 +21,13 @@ _export(exports, {
     }
 });
 const _fs = require("fs");
-const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
 const _picocolors = require("../picocolors");
 const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("next/dist/compiled/comment-json"));
 const _semver = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/semver"));
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _typepaths = require("./type-paths");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../build/output/log"));
+const _configshared = require("../../server/config-shared");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -279,22 +280,10 @@ async function writeConfigurationDefaults(typescriptVersion, tsConfigPath, isFir
             const _ = check;
         }
     }
-    const distDirPosix = _path.win32.sep === _path.sep ? distDir.replaceAll(_path.win32.sep, _path.posix.sep) : distDir;
-    const nextAppTypes = [
-        `${distDirPosix}/types/**/*.ts`
-    ];
-    // When isolatedDevBuild is enabled, Next.js uses different distDir paths:
-    // - Development: "{distDir}/dev"
-    // - Production: "{distDir}"
-    // To prevent tsconfig updates when switching between dev/build modes,
-    // we proactively include both type paths regardless of current environment.
-    if (isolatedDevBuild !== false) {
-        nextAppTypes.push(process.env.NODE_ENV === 'development' ? // Here we remove "/dev" at the end of distDir for consistency.
-        `${distDirPosix.replace(/\/dev$/, '')}/types/**/*.ts` : // Here we add "/dev" at the end of distDir for consistency.
-        `${distDirPosix}/dev/types/**/*.ts`);
-        // Sort the array to ensure consistent order.
-        nextAppTypes.sort((a, b)=>a.length - b.length);
-    }
+    const resolvedIsolatedDevBuild = isolatedDevBuild === undefined ? _configshared.defaultConfig.experimental.isolatedDevBuild : isolatedDevBuild;
+    // Get type definition glob patterns using shared utility to ensure consistency
+    // with other TypeScript infrastructure (e.g., runTypeCheck.ts)
+    const nextAppTypes = (0, _typepaths.getTypeDefinitionGlobPatterns)(distDir, resolvedIsolatedDevBuild);
     if (!('include' in userTsConfig)) {
         userTsConfig.include = hasAppDir ? [
             'next-env.d.ts',

qalita/_frontend/node_modules/next/dist/lib/verify-typescript-setup.js

@@ -83,9 +83,14 @@ const requiredPackages = [
         exportsRestrict: true
     }
 ];
-async function verifyTypeScriptSetup({ dir, distDir, cacheDir, intentDirs, tsconfigPath, typeCheckPreflight, disableStaticImages, hasAppDir, hasPagesDir, isolatedDevBuild }) {
+async function verifyTypeScriptSetup({ dir, distDir, cacheDir, tsconfigPath, typeCheckPreflight, disableStaticImages, hasAppDir, hasPagesDir, isolatedDevBuild, appDir, pagesDir, debugBuildPaths }) {
     const tsConfigFileName = tsconfigPath || 'tsconfig.json';
     const resolvedTsConfigPath = _path.default.join(dir, tsConfigFileName);
+    // Construct intentDirs from appDir and pagesDir for getTypeScriptIntent
+    const intentDirs = [
+        pagesDir,
+        appDir
+    ].filter(Boolean);
     try {
         var _deps_missing;
         // Check if the project uses TypeScript:
@@ -136,7 +141,10 @@ async function verifyTypeScriptSetup({ dir, distDir, cacheDir, intentDirs, tscon
             const tsPath = deps.resolved.get('typescript');
             const typescript = await Promise.resolve(require(tsPath));
             // Verify the project passes type-checking before we go to webpack phase:
-            result = await runTypeCheck(typescript, dir, distDir, resolvedTsConfigPath, cacheDir, hasAppDir);
+            result = await runTypeCheck(typescript, dir, distDir, resolvedTsConfigPath, cacheDir, hasAppDir, isolatedDevBuild, {
+                app: appDir,
+                pages: pagesDir
+            }, debugBuildPaths);
         }
         return {
             result,

qalita/_frontend/node_modules/next/dist/lib/worker.js

@@ -37,7 +37,9 @@ function getNextBuildDebuggerPortOffset(_) {
 }
 class Worker {
     constructor(workerPath, options){
-        let { enableSourceMaps, timeout, onRestart, logger = console, debuggerPortOffset, isolatedMemory, ...farmOptions } = options;
+        let { enableSourceMaps, timeout, onRestart, logger = console, debuggerPortOffset, isolatedMemory, onActivity, onActivityAbort, ...farmOptions } = options;
+        this._onActivity = onActivity;
+        this._onActivityAbort = onActivityAbort;
         let restartPromise;
         let resolveRestartPromise;
         let activeTasks = 0;
@@ -124,22 +126,22 @@ class Worker {
                     });
                     (_worker__child1 = worker._child) == null ? void 0 : _worker__child1.on('message', ([, data])=>{
                         if (data && typeof data === 'object' && 'type' in data && data.type === 'activity') {
-                            onActivity();
+                            onActivityImpl();
                         }
                     });
                 }
             }
             let aborted = false;
-            const onActivityAbort = ()=>{
+            const onActivityAbortImpl = ()=>{
                 if (!aborted) {
-                    options.onActivityAbort == null ? void 0 : options.onActivityAbort.call(options);
+                    this._onActivityAbort == null ? void 0 : this._onActivityAbort.call(this);
                     aborted = true;
                 }
             };
             // Listen to the worker's stdout and stderr, if there's any thing logged, abort the activity first
             const abortActivityStreamOnLog = new _stream.Transform({
                 transform (_chunk, _encoding, callback) {
-                    onActivityAbort();
+                    onActivityAbortImpl();
                     callback();
                 }
             });
@@ -162,9 +164,9 @@ class Worker {
             });
         };
         let hangingTimer = false;
-        const onActivity = ()=>{
+        const onActivityImpl = ()=>{
             if (hangingTimer) clearTimeout(hangingTimer);
-            if (options.onActivity) options.onActivity();
+            if (this._onActivity) this._onActivity();
             hangingTimer = activeTasks > 0 && setTimeout(onHanging, timeout);
         };
         for (const method of farmOptions.exposedMethods){
@@ -174,7 +176,7 @@ class Worker {
                 try {
                     let attempts = 0;
                     for(;;){
-                        onActivity();
+                        onActivityImpl();
                         const result = await Promise.race([
                             this._worker[method](...args),
                             restartPromise
@@ -184,11 +186,17 @@ class Worker {
                     }
                 } finally{
                     activeTasks--;
-                    onActivity();
+                    onActivityImpl();
                 }
             } : this._worker[method].bind(this._worker);
         }
     }
+    setOnActivity(onActivity) {
+        this._onActivity = onActivity;
+    }
+    setOnActivityAbort(onActivityAbort) {
+        this._onActivityAbort = onActivityAbort;
+    }
     end() {
         const worker = this._worker;
         if (!worker) {

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

@@ -35,7 +35,7 @@ const _log = require("../../build/output/log");
 const _cookies = require("../web/spec-extension/cookies");
 const _headers = require("../web/spec-extension/adapters/headers");
 const _utils1 = require("../web/utils");
-const _actionutils = require("./action-utils");
+const _manifestssingleton = require("./manifests-singleton");
 const _helpers = require("../base-http/helpers");
 const _redirectstatuscode = require("../../client/components/redirect-status-code");
 const _requeststore = require("../async-storage/request-store");
@@ -44,6 +44,7 @@ const _invarianterror = require("../../shared/lib/invariant-error");
 const _revalidationutils = require("../revalidation-utils");
 const _requestmeta = require("../request-meta");
 const _setcachebustingsearchparam = require("../../client/components/router-reducer/set-cache-busting-search-param");
+const _actionrevalidationkind = require("../../shared/lib/action-revalidation-kind");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -51,8 +52,9 @@ function _interop_require_default(obj) {
 }
 /**
  * Checks if the app has any server actions defined in any runtime.
- */ function hasServerActions(manifest) {
-    return Object.keys(manifest.node).length > 0 || Object.keys(manifest.edge).length > 0;
+ */ function hasServerActions() {
+    const serverActionsManifest = (0, _manifestssingleton.getServerActionsManifest)();
+    return Object.keys(serverActionsManifest.node).length > 0 || Object.keys(serverActionsManifest.edge).length > 0;
 }
 function nodeHeadersToRecord(headers) {
     const record = {};
@@ -95,20 +97,23 @@ function addRevalidationHeader(res, { workStore, requestStore }) {
     // If a tag was revalidated, the client router needs to invalidate all the
     // client router cache as they may be stale. And if a path was revalidated, the
     // client needs to invalidate all subtrees below that path.
-    // To keep the header size small, we use a tuple of
-    // [[revalidatedPaths], isTagRevalidated ? 1 : 0, isCookieRevalidated ? 1 : 0]
-    // instead of a JSON object.
+    // TODO: Currently we don't send the specific tags or paths to the client,
+    // we just send a flag indicating that all the static data on the client
+    // should be invalidated. In the future, this will likely be a Bloom filter
+    // or bitmask of some kind.
     // TODO-APP: Currently the prefetch cache doesn't have subtree information,
     // so we need to invalidate the entire cache if a path was revalidated.
     // TODO-APP: Currently paths are treated as tags, so the second element of the tuple
     // is always empty.
     const isTagRevalidated = ((_workStore_pendingRevalidatedTags = workStore.pendingRevalidatedTags) == null ? void 0 : _workStore_pendingRevalidatedTags.length) ? 1 : 0;
     const isCookieRevalidated = (0, _requestcookies.getModifiedCookieValues)(requestStore.mutableCookies).length ? 1 : 0;
-    res.setHeader('x-action-revalidated', JSON.stringify([
-        [],
-        isTagRevalidated,
-        isCookieRevalidated
-    ]));
+    // First check if a tag, cookie, or path was revalidated.
+    if (isTagRevalidated || isCookieRevalidated) {
+        res.setHeader(_approuterheaders.NEXT_ACTION_REVALIDATED_HEADER, JSON.stringify(_actionrevalidationkind.ActionDidRevalidateStaticAndDynamic));
+    } else if (// Check for refresh() actions. This will invalidate only the dynamic data.
+    workStore.pathWasRevalidated !== undefined && workStore.pathWasRevalidated !== _actionrevalidationkind.ActionDidNotRevalidate) {
+        res.setHeader(_approuterheaders.NEXT_ACTION_REVALIDATED_HEADER, JSON.stringify(workStore.pathWasRevalidated));
+    }
 }
 /**
  * Forwards a server action request to a separate worker. Used when the requested action is not available in the current worker.
@@ -315,9 +320,10 @@ function parseHostHeader(headers, originDomain) {
         value: hostHeader
     } : undefined;
 }
-async function handleAction({ req, res, ComponentMod, serverModuleMap, generateFlight, workStore, requestStore, serverActions, ctx, metadata }) {
+async function handleAction({ req, res, ComponentMod, generateFlight, workStore, requestStore, serverActions, ctx, metadata }) {
     const contentType = req.headers['content-type'];
-    const { serverActionsManifest, page } = ctx.renderOpts;
+    const { page } = ctx.renderOpts;
+    const serverModuleMap = (0, _manifestssingleton.getServerModuleMap)();
     const { actionId, isMultipartAction, isFetchAction, isURLEncodedAction, isPossibleServerAction } = (0, _serveractionrequestmeta.getServerActionRequestMetadata)(req);
     const handleUnrecognizedFetchAction = (err)=>{
         // If the deployment doesn't have skew protection, this is expected to occasionally happen,
@@ -354,7 +360,7 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
         }
     }
     // If the app has no server actions at all, we can 404 early.
-    if (!hasServerActions(serverActionsManifest)) {
+    if (!hasServerActions()) {
         return handleUnrecognizedFetchAction(getActionNotFoundError(actionId));
     }
     if (workStore.isStaticGeneration) {
@@ -418,8 +424,9 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                     type: 'done',
                     result: await generateFlight(req, ctx, requestStore, {
                         actionResult: promise,
-                        // We didn't execute an action, so no revalidations could have occurred. We can skip rendering the page.
-                        skipFlight: true,
+                        // We didn't execute an action, so no revalidations could have
+                        // occurred. We can skip rendering the page.
+                        skipPageRendering: true,
                         temporaryReferences
                     })
                 };
@@ -432,7 +439,7 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
     const { actionAsyncStorage } = ComponentMod;
     const actionWasForwarded = Boolean(req.headers['x-action-forwarded']);
     if (actionId) {
-        const forwardedWorker = (0, _actionutils.selectWorkerForForwarding)(actionId, page, serverActionsManifest);
+        const forwardedWorker = (0, _manifestssingleton.selectWorkerForForwarding)(actionId, page);
         // If forwardedWorker is truthy, it means there isn't a worker for the action
         // in the current handler, so we forward the request to a worker that has the action.
         if (forwardedWorker) {
@@ -483,7 +490,7 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                             // TODO: This can be from skew or manipulated input. We should handle this case
                             // more gracefully but this preserves the prior behavior where decodeAction would throw instead.
                             throw Object.defineProperty(new Error(`Failed to find Server Action. This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
-                                value: "E911",
+                                value: "E975",
                                 enumerable: false,
                                 configurable: true
                             });
@@ -493,8 +500,8 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                             // an MPA action.
                             // Only warn if it's a server action, otherwise skip for other post requests
                             warnBadServerActionRequest();
-                            const actionReturnedState = await executeActionAndPrepareForRender(action, [], workStore, requestStore);
-                            const formState = await decodeFormState(actionReturnedState, formData, serverModuleMap);
+                            const { actionResult } = await executeActionAndPrepareForRender(action, [], workStore, requestStore, actionWasForwarded);
+                            const formState = await decodeFormState(actionResult, formData, serverModuleMap);
                             // Skip the fetch path.
                             // We need to render a full HTML version of the page for the response, we'll handle that in app-render.
                             return {
@@ -542,7 +549,8 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                 // Use react-server-dom-webpack/server.node which supports streaming
                 const { createTemporaryReferenceSet, decodeReply, decodeReplyFromBusboy, decodeAction, decodeFormState } = require(`./react-server.node`);
                 temporaryReferences = createTemporaryReferenceSet();
-                const { Transform, pipeline } = require('node:stream');
+                const { PassThrough, Readable, Transform } = require('node:stream');
+                const { pipeline } = require('node:stream/promises');
                 const defaultBodySizeLimit = '1 MB';
                 const bodySizeLimit = (serverActions == null ? void 0 : serverActions.bodySizeLimit) ?? defaultBodySizeLimit;
                 const bodySizeLimitBytes = bodySizeLimit !== defaultBodySizeLimit ? require('next/dist/compiled/bytes').parse(bodySizeLimit) : 1024 * 1024 // 1 MB
@@ -563,9 +571,6 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                         callback(null, chunk);
                     }
                 });
-                const sizeLimitedBody = pipeline(req.body, sizeLimitTransform, // Avoid unhandled errors from `pipeline()` by passing an empty completion callback.
-                // We'll propagate the errors properly when consuming the stream.
-                ()=>{});
                 if (isMultipartAction) {
                     if (isFetchAction) {
                         // A fetch action with a multipart body.
@@ -581,16 +586,25 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                                 fieldSize: bodySizeLimitBytes
                             }
                         });
-                        // We need to use `pipeline(one, two)` instead of `one.pipe(two)` to propagate size limit errors correctly.
-                        pipeline(sizeLimitedBody, busboy, // Avoid unhandled errors from `pipeline()` by passing an empty completion callback.
-                        // We'll propagate the errors properly when consuming the stream.
-                        ()=>{});
-                        boundActionArguments = await decodeReplyFromBusboy(busboy, serverModuleMap, {
-                            temporaryReferences
-                        });
+                        const abortController = new AbortController();
+                        try {
+                            ;
+                            [, boundActionArguments] = await Promise.all([
+                                pipeline(req.body, sizeLimitTransform, busboy, {
+                                    signal: abortController.signal
+                                }),
+                                decodeReplyFromBusboy(busboy, serverModuleMap, {
+                                    temporaryReferences
+                                })
+                            ]);
+                        } catch (err) {
+                            abortController.abort();
+                            throw err;
+                        }
                     } else {
                         // Multipart POST, but not a fetch action.
                         // Potentially an MPA action, we have to try decoding it to check.
+                        const sizeLimitedBody = new PassThrough();
                         // React doesn't yet publish a busboy version of decodeAction
                         // so we polyfill the parsing of FormData.
                         const fakeRequest = new Request('http://localhost', {
@@ -599,27 +613,28 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                             headers: {
                                 'Content-Type': contentType
                             },
-                            body: new ReadableStream({
-                                start: (controller)=>{
-                                    sizeLimitedBody.on('data', (chunk)=>{
-                                        controller.enqueue(new Uint8Array(chunk));
-                                    });
-                                    sizeLimitedBody.on('end', ()=>{
-                                        controller.close();
-                                    });
-                                    sizeLimitedBody.on('error', (err)=>{
-                                        controller.error(err);
-                                    });
-                                }
-                            }),
+                            body: Readable.toWeb(sizeLimitedBody),
                             duplex: 'half'
                         });
-                        const formData = await fakeRequest.formData();
+                        let formData;
+                        const abortController = new AbortController();
+                        try {
+                            ;
+                            [, formData] = await Promise.all([
+                                pipeline(req.body, sizeLimitTransform, sizeLimitedBody, {
+                                    signal: abortController.signal
+                                }),
+                                fakeRequest.formData()
+                            ]);
+                        } catch (err) {
+                            abortController.abort();
+                            throw err;
+                        }
                         if (areAllActionIdsValid(formData, serverModuleMap) === false) {
                             // TODO: This can be from skew or manipulated input. We should handle this case
                             // more gracefully but this preserves the prior behavior where decodeAction would throw instead.
                             throw Object.defineProperty(new Error(`Failed to find Server Action. This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
-                                value: "E911",
+                                value: "E975",
                                 enumerable: false,
                                 configurable: true
                             });
@@ -631,8 +646,8 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                             // an MPA action.
                             // Only warn if it's a server action, otherwise skip for other post requests
                             warnBadServerActionRequest();
-                            const actionReturnedState = await executeActionAndPrepareForRender(action, [], workStore, requestStore);
-                            const formState = await decodeFormState(actionReturnedState, formData, serverModuleMap);
+                            const { actionResult } = await executeActionAndPrepareForRender(action, [], workStore, requestStore, actionWasForwarded);
+                            const formState = await decodeFormState(actionResult, formData, serverModuleMap);
                             // Skip the fetch path.
                             // We need to render a full HTML version of the page for the response, we'll handle that in app-render.
                             return {
@@ -660,10 +675,16 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                     // A fetch action with a non-multipart body.
                     // In practice, this happens if `encodeReply` returned a string instead of FormData,
                     // which can happen for very simple JSON-like values that don't need multiple flight rows.
+                    const sizeLimitedBody = new PassThrough();
                     const chunks = [];
-                    for await (const chunk of sizeLimitedBody){
-                        chunks.push(Buffer.from(chunk));
-                    }
+                    await Promise.all([
+                        pipeline(req.body, sizeLimitTransform, sizeLimitedBody),
+                        (async ()=>{
+                            for await (const chunk of sizeLimitedBody){
+                                chunks.push(Buffer.from(chunk));
+                            }
+                        })()
+                    ]);
                     const actionData = Buffer.concat(chunks).toString('utf-8');
                     boundActionArguments = await decodeReply(actionData, serverModuleMap, {
                         temporaryReferences
@@ -688,7 +709,7 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
             const actionMod = await ComponentMod.__next_app__.require(actionModId);
             const actionHandler = actionMod[// `actionId` must exist if we got here, as otherwise we would have thrown an error above
             actionId];
-            const returnVal = await executeActionAndPrepareForRender(actionHandler, boundActionArguments, workStore, requestStore).finally(()=>{
+            const { actionResult, skipPageRendering } = await executeActionAndPrepareForRender(actionHandler, boundActionArguments, workStore, requestStore, actionWasForwarded).finally(()=>{
                 addRevalidationHeader(res, {
                     workStore,
                     requestStore
@@ -696,15 +717,17 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
             });
             // For form actions, we need to continue rendering the page.
             if (isFetchAction) {
-                const actionResult = await generateFlight(req, ctx, requestStore, {
-                    actionResult: Promise.resolve(returnVal),
-                    // if the page was not revalidated, or if the action was forwarded from another worker, we can skip the rendering the flight tree
-                    skipFlight: !workStore.pathWasRevalidated || actionWasForwarded,
-                    temporaryReferences
-                });
                 return {
                     type: 'done',
-                    result: actionResult
+                    result: await generateFlight(req, ctx, requestStore, {
+                        actionResult: Promise.resolve(actionResult),
+                        skipPageRendering,
+                        temporaryReferences,
+                        // If we skip page rendering, we need to ensure pending
+                        // revalidates are awaited before closing the response. Otherwise,
+                        // this will be done after rendering the page.
+                        waitUntil: skipPageRendering ? (0, _revalidationutils.executeRevalidates)(workStore) : undefined
+                    })
                 };
             } else {
                 // TODO: this shouldn't be reachable, because all non-fetch codepaths return early.
@@ -749,7 +772,7 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                 return {
                     type: 'done',
                     result: await generateFlight(req, ctx, requestStore, {
-                        skipFlight: false,
+                        skipPageRendering: false,
                         actionResult: promise,
                         temporaryReferences
                     })
@@ -782,8 +805,9 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
                 type: 'done',
                 result: await generateFlight(req, ctx, requestStore, {
                     actionResult: promise,
-                    // if the page was not revalidated, or if the action was forwarded from another worker, we can skip the rendering the flight tree
-                    skipFlight: !workStore.pathWasRevalidated || actionWasForwarded,
+                    // If the page was not revalidated, or if the action was forwarded
+                    // from another worker, we can skip rendering the page.
+                    skipPageRendering: workStore.pathWasRevalidated === undefined || workStore.pathWasRevalidated === _actionrevalidationkind.ActionDidNotRevalidate || actionWasForwarded,
                     temporaryReferences
                 })
             };
@@ -792,23 +816,35 @@ async function handleAction({ req, res, ComponentMod, serverModuleMap, generateF
         throw err;
     }
 }
-async function executeActionAndPrepareForRender(action, args, workStore, requestStore) {
+async function executeActionAndPrepareForRender(action, args, workStore, requestStore, actionWasForwarded) {
     requestStore.phase = 'action';
+    let skipPageRendering = actionWasForwarded;
     try {
-        return await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>action.apply(null, args));
+        const actionResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>action.apply(null, args));
+        // If the page was not revalidated, or if the action was forwarded from
+        // another worker, we can skip rendering the page.
+        skipPageRendering ||= workStore.pathWasRevalidated === undefined || workStore.pathWasRevalidated === _actionrevalidationkind.ActionDidNotRevalidate;
+        return {
+            actionResult,
+            skipPageRendering
+        };
     } finally{
-        requestStore.phase = 'render';
-        // When we switch to the render phase, cookies() will return
-        // `workUnitStore.cookies` instead of `workUnitStore.userspaceMutableCookies`.
-        // We want the render to see any cookie writes that we performed during the action,
-        // so we need to update the immutable cookies to reflect the changes.
-        (0, _requeststore.synchronizeMutableCookies)(requestStore);
-        // The server action might have toggled draft mode, so we need to reflect
-        // that in the work store to be up-to-date for subsequent rendering.
-        workStore.isDraftMode = requestStore.draftMode.isEnabled;
-        // If the action called revalidateTag/revalidatePath, then that might affect data used by the subsequent render,
-        // so we need to make sure all revalidations are applied before that
-        await (0, _revalidationutils.executeRevalidates)(workStore);
+        if (!skipPageRendering) {
+            requestStore.phase = 'render';
+            // When we switch to the render phase, cookies() will return
+            // `workUnitStore.cookies` instead of
+            // `workUnitStore.userspaceMutableCookies`. We want the render to see any
+            // cookie writes that we performed during the action, so we need to update
+            // the immutable cookies to reflect the changes.
+            (0, _requeststore.synchronizeMutableCookies)(requestStore);
+            // The server action might have toggled draft mode, so we need to reflect
+            // that in the work store to be up-to-date for subsequent rendering.
+            workStore.isDraftMode = requestStore.draftMode.isEnabled;
+            // If the action called revalidateTag/revalidatePath, then that might
+            // affect data used by the subsequent render, so we need to make sure all
+            // revalidations are applied before that.
+            await (0, _revalidationutils.executeRevalidates)(workStore);
+        }
     }
 }
 /**
@@ -833,7 +869,7 @@ async function executeActionAndPrepareForRender(action, args, workStore, request
 }
 function getActionNotFoundError(actionId) {
     return Object.defineProperty(new Error(`Failed to find Server Action${actionId ? ` "${actionId}"` : ''}. This request might be from an older or newer deployment.\nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
-        value: "E912",
+        value: "E974",
         enumerable: false,
         configurable: true
     });