@semiont/frontend 0.3.3 → 0.3.4

package/standalone/node_modules/next/dist/lib/verify-typescript-setup.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "verifyTypeScriptSetup", {
+Object.defineProperty(exports, "verifyAndRunTypeScript", {
     enumerable: true,
     get: function() {
-        return verifyTypeScriptSetup;
+        return verifyAndRunTypeScript;
     }
 });
 const _picocolors = require("./picocolors");
@@ -20,6 +20,7 @@ const _writeConfigurationDefaults = require("./typescript/writeConfigurationDefa
 const _installdependencies = require("./install-dependencies");
 const _ciinfo = require("../server/ci-info");
 const _missingDependencyError = require("./typescript/missingDependencyError");
+const _resolvefrom = require("./resolve-from");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -66,12 +67,13 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+const typescriptPackage = {
+    file: 'typescript/lib/typescript.js',
+    pkg: 'typescript',
+    exportsRestrict: true
+};
 const requiredPackages = [
-    {
-        file: 'typescript/lib/typescript.js',
-        pkg: 'typescript',
-        exportsRestrict: true
-    },
+    typescriptPackage,
     {
         file: '@types/react/index.d.ts',
         pkg: '@types/react',
@@ -83,7 +85,19 @@ const requiredPackages = [
         exportsRestrict: true
     }
 ];
-async function verifyTypeScriptSetup({ dir, distDir, cacheDir, tsconfigPath, typeCheckPreflight, disableStaticImages, hasAppDir, hasPagesDir, isolatedDevBuild, appDir, pagesDir, debugBuildPaths }) {
+/**
+ * Check if @typescript/native-preview is installed as an alternative TypeScript compiler.
+ * This is a Go-based native TypeScript compiler that can be used instead of the standard
+ * TypeScript package for faster compilation.
+ */ function hasNativeTypeScriptPreview(dir) {
+    try {
+        (0, _resolvefrom.resolveFrom)(dir, '@typescript/native-preview/package.json');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function verifyAndRunTypeScript({ dir, distDir, cacheDir, strictRouteTypes, tsconfigPath, shouldRunTypeCheck, typedRoutes, disableStaticImages, hasAppDir, hasPagesDir, appDir, pagesDir, debugBuildPaths }) {
     const tsConfigFileName = tsconfigPath || 'tsconfig.json';
     const resolvedTsConfigPath = _path.default.join(dir, tsConfigFileName);
     // Construct intentDirs from appDir and pagesDir for getTypeScriptIntent
@@ -92,7 +106,7 @@ async function verifyTypeScriptSetup({ dir, distDir, cacheDir, tsconfigPath, typ
         appDir
     ].filter(Boolean);
     try {
-        var _deps_missing;
+        var _deps_missing, _deps_missing1;
         // Check if the project uses TypeScript:
         const intent = await (0, _getTypeScriptIntent.getTypeScriptIntent)(dir, intentDirs, tsConfigFileName);
         if (!intent) {
@@ -100,9 +114,40 @@ async function verifyTypeScriptSetup({ dir, distDir, cacheDir, tsconfigPath, typ
                 version: null
             };
         }
+        // Check if @typescript/native-preview is installed as an alternative
+        const hasNativePreview = hasNativeTypeScriptPreview(dir);
         // Ensure TypeScript and necessary `@types/*` are installed:
         let deps = (0, _hasnecessarydependencies.hasNecessaryDependencies)(dir, requiredPackages);
-        if (((_deps_missing = deps.missing) == null ? void 0 : _deps_missing.length) > 0) {
+        // If @typescript/native-preview is installed and only the typescript package is missing,
+        // we can skip auto-installing typescript since the native preview provides TS compilation.
+        // However, we still need @types/react and @types/node for type checking.
+        if (hasNativePreview && ((_deps_missing = deps.missing) == null ? void 0 : _deps_missing.length) > 0) {
+            const missingWithoutTypescript = deps.missing.filter((dep)=>dep.pkg !== 'typescript');
+            const onlyTypescriptMissing = deps.missing.length === 1 && deps.missing[0].pkg === 'typescript';
+            if (onlyTypescriptMissing) {
+                // @typescript/native-preview is installed and only typescript is missing
+                // Skip installation and return early - the project can use the native preview
+                _log.info(`Detected ${(0, _picocolors.bold)('@typescript/native-preview')} as TypeScript compiler. ` + `Some Next.js TypeScript features (like type checking during build) require the standard ${(0, _picocolors.bold)('typescript')} package.`);
+                // Still write type declarations since they don't require the typescript package
+                await (0, _writeAppTypeDeclarations.writeAppTypeDeclarations)({
+                    baseDir: dir,
+                    distDir,
+                    imageImportsEnabled: !disableStaticImages,
+                    hasPagesDir,
+                    hasAppDir,
+                    strictRouteTypes,
+                    typedRoutes
+                });
+                return {
+                    version: null
+                };
+            }
+            // If there are other missing deps besides typescript, only install those
+            if (missingWithoutTypescript.length > 0 && missingWithoutTypescript.length < deps.missing.length) {
+                deps.missing = missingWithoutTypescript;
+            }
+        }
+        if (((_deps_missing1 = deps.missing) == null ? void 0 : _deps_missing1.length) > 0) {
             if (_ciinfo.isCI) {
                 // we don't attempt auto install in CI to avoid side-effects
                 // and instead log the error for installing needed packages
@@ -125,7 +170,7 @@ async function verifyTypeScriptSetup({ dir, distDir, cacheDir, tsconfigPath, typ
             _log.warn(`Minimum recommended TypeScript version is v5.1.0, older versions can potentially be incompatible with Next.js. Detected: ${typescriptVersion}`);
         }
         // Reconfigure (or create) the user's `tsconfig.json` for them:
-        await (0, _writeConfigurationDefaults.writeConfigurationDefaults)(typescriptVersion, resolvedTsConfigPath, intent.firstTimeSetup, hasAppDir, distDir, hasPagesDir, isolatedDevBuild);
+        await (0, _writeConfigurationDefaults.writeConfigurationDefaults)(typescriptVersion, resolvedTsConfigPath, intent.firstTimeSetup, hasAppDir, distDir, hasPagesDir, strictRouteTypes);
         // Write out the necessary `next-env.d.ts` file to correctly register
         // Next.js' types:
         await (0, _writeAppTypeDeclarations.writeAppTypeDeclarations)({
@@ -133,15 +178,20 @@ async function verifyTypeScriptSetup({ dir, distDir, cacheDir, tsconfigPath, typ
             distDir,
             imageImportsEnabled: !disableStaticImages,
             hasPagesDir,
-            hasAppDir
+            hasAppDir,
+            strictRouteTypes,
+            typedRoutes
         });
         let result;
-        if (typeCheckPreflight) {
+        if (shouldRunTypeCheck) {
             const { runTypeCheck } = require('./typescript/runTypeCheck');
+            // Install native bindings so that code frame rendering works in the worker
+            const { installBindings } = require('../build/swc/install-bindings');
+            await installBindings();
             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, isolatedDevBuild, {
+            result = await runTypeCheck(typescript, dir, distDir, resolvedTsConfigPath, cacheDir, hasAppDir, {
                 app: appDir,
                 pages: pagesDir
             }, debugBuildPaths);
@@ -153,12 +203,12 @@ async function verifyTypeScriptSetup({ dir, distDir, cacheDir, tsconfigPath, typ
     } catch (err) {
         // These are special errors that should not show a stack trace:
         if (err instanceof _compileerror.CompileError) {
-            console.error((0, _picocolors.red)('Failed to compile.\n'));
+            console.error((0, _picocolors.red)('Failed to type check.\n'));
             console.error(err.message);
             process.exit(1);
         }
         /**
-     * verifyTypeScriptSetup can be either invoked directly in the main thread (during next dev / next lint)
+     * verifyAndRunTypeScript can be either invoked directly in the main thread (during next dev / next lint)
      * or run in a worker (during next build). In the latter case, we need to print the error message, as the
      * parent process will only receive an `Jest worker encountered 1 child process exceptions, exceeding retry limit`.
      */ // we are in a worker, print the error message and exit the process

package/standalone/node_modules/next/dist/next-devtools/server/shared.js

@@ -20,9 +20,7 @@ _export(exports, {
         return ignoreListAnonymousStackFramesIfSandwiched;
     }
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _codeframe = require("next/dist/compiled/babel/code-frame");
-const _isinternal = /*#__PURE__*/ _interop_require_default._(require("../../shared/lib/is-internal"));
+const _codeframe = require("../../shared/lib/errors/code-frame");
 const _sourcemaps = require("../../server/lib/source-maps");
 function ignoreListAnonymousStackFramesIfSandwiched(responses) {
     (0, _sourcemaps.ignoreListAnonymousStackFramesIfSandwiched)(responses, (response)=>{
@@ -37,19 +35,17 @@ function ignoreListAnonymousStackFramesIfSandwiched(responses) {
     });
 }
 function getOriginalCodeFrame(frame, source, colors = process.stdout.isTTY) {
-    if (!source || (0, _isinternal.default)(frame.file)) {
+    if (!source || frame.line1 == null) {
         return null;
     }
     return (0, _codeframe.codeFrameColumns)(source, {
         start: {
-            // 1-based, but -1 means start line without highlighting
-            line: frame.line1 ?? -1,
-            // 1-based, but 0 means whole line without column highlighting
-            column: frame.column1 ?? 0
+            line: frame.line1,
+            column: frame.column1 ?? undefined
         }
     }, {
-        forceColor: colors
-    });
+        color: colors
+    }) ?? null;
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

package/standalone/node_modules/next/dist/next-devtools/shared/webpack-module-path.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    formatFrameSourceFile: null,
+    formatStackFrameFile: null,
     isWebpackInternalResource: null
 });
 function _export(target, all) {
@@ -13,8 +13,8 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    formatFrameSourceFile: function() {
-        return formatFrameSourceFile;
+    formatStackFrameFile: function() {
+        return formatStackFrameFile;
     },
     isWebpackInternalResource: function() {
         return isWebpackInternalResource;
@@ -31,7 +31,7 @@ function isWebpackInternalResource(file) {
     }
     return false;
 }
-function formatFrameSourceFile(file) {
+function formatStackFrameFile(file) {
     for (const regex of replacementRegExes){
         file = file.replace(regex, '');
     }

package/standalone/node_modules/next/dist/next-devtools/userspace/app/app-dev-overlay-error-boundary.js

@@ -9,14 +9,16 @@ Object.defineProperty(exports, "AppDevOverlayErrorBoundary", {
     }
 });
 const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _jsxruntime = require("react/jsx-runtime");
-const _react = require("react");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _nextdevtools = require("next/dist/compiled/next-devtools");
 const _runtimeerrorhandler = require("../../../client/dev/runtime-error-handler");
 const _errorboundary = require("../../../client/components/error-boundary");
 const _globalerror = /*#__PURE__*/ _interop_require_default._(require("../../../client/components/builtin/global-error"));
 const _segmentexplorernode = require("./segment-explorer-node");
-function ErroredHtml({ globalError: [GlobalError, globalErrorStyles], error }) {
+const _approutercontextsharedruntime = require("../../../shared/lib/app-router-context.shared-runtime");
+function ErroredHtml({ globalError: [GlobalError, globalErrorStyles], error, reset, unstable_retry }) {
     if (!error) {
         return /*#__PURE__*/ (0, _jsxruntime.jsxs)("html", {
             children: [
@@ -30,12 +32,17 @@ function ErroredHtml({ globalError: [GlobalError, globalErrorStyles], error }) {
         children: [
             globalErrorStyles,
             /*#__PURE__*/ (0, _jsxruntime.jsx)(GlobalError, {
-                error: error
+                error: error,
+                reset: reset,
+                unstable_retry: unstable_retry
             })
         ]
     });
 }
 class AppDevOverlayErrorBoundary extends _react.PureComponent {
+    static{
+        this.contextType = _approutercontextsharedruntime.AppRouterContext;
+    }
     static getDerivedStateFromError(error) {
         _runtimeerrorhandler.RuntimeErrorHandler.hadRuntimeError = true;
         return {
@@ -53,13 +60,24 @@ class AppDevOverlayErrorBoundary extends _react.PureComponent {
         const { reactError } = this.state;
         const fallback = /*#__PURE__*/ (0, _jsxruntime.jsx)(ErroredHtml, {
             globalError: globalError,
-            error: reactError
+            error: reactError,
+            reset: this.reset,
+            unstable_retry: this.unstable_retry
         });
         return reactError !== null ? fallback : children;
     }
     constructor(...args){
         super(...args), this.state = {
             reactError: null
+        }, this.unstable_retry = ()=>{
+            (0, _react.startTransition)(()=>{
+                this.context?.refresh();
+                this.reset();
+            });
+        }, this.reset = ()=>{
+            this.setState({
+                reactError: null
+            });
         };
     }
 }

package/standalone/node_modules/next/dist/next-devtools/userspace/app/errors/stitched-error.js

@@ -52,7 +52,13 @@ function coerceError(value) {
 function setOwnerStackIfAvailable(error) {
     // React 18 and prod does not have `captureOwnerStack`
     if ('captureOwnerStack' in _react.default) {
-        setOwnerStack(error, _react.default.captureOwnerStack());
+        const ownerStack = _react.default.captureOwnerStack();
+        // Only set if we captured a valid owner stack, or if none exists yet.
+        // This prevents overwriting a valid owner stack captured earlier
+        // (e.g., in onRecoverableError) with null captured later.
+        if (ownerStack || !ownerStacks.has(error)) {
+            setOwnerStack(error, ownerStack);
+        }
     }
 }
 function decorateDevError(thrownValue) {

package/standalone/node_modules/next/dist/next-devtools/userspace/app/forward-logs.js

@@ -32,11 +32,11 @@ _export(exports, {
         return logUnhandledRejection;
     }
 });
-const _stitchederror = require("./errors/stitched-error");
 const _errorsource = require("../../../shared/lib/error-source");
 const _terminalloggingconfig = require("./terminal-logging-config");
 const _forwardlogsshared = require("../../shared/forward-logs-shared");
 const _forwardlogsutils = require("./forward-logs-utils");
+const _stitchederror = require("./errors/stitched-error");
 // Client-side file logger for browser logs
 class ClientFileLogger {
     formatTimestamp() {
@@ -289,11 +289,10 @@ const stringifyUserArg = (arg)=>{
     };
 };
 const createErrorArg = (error)=>{
-    const stack = stackWithOwners(error);
     return {
         kind: 'formatted-error-arg',
         prefix: error.message ? `${error.name}: ${error.message}` : `${error.name}`,
-        stack
+        stack: getErrorStackWithOwnerStack(error)
     };
 };
 const createLogEntry = (level, args)=>{
@@ -305,7 +304,7 @@ const createLogEntry = (level, args)=>{
     }
     // do not abstract this, it implicitly relies on which functions call it. forcing the inlined implementation makes you think about callers
     // error capture stack trace maybe
-    const stack = stackWithOwners(new Error());
+    const stack = getErrorStack(new Error());
     const stackLines = stack?.split('\n');
     const cleanStack = stackLines?.slice(3).join('\n') // this is probably ignored anyways
     ;
@@ -326,6 +325,10 @@ const createLogEntry = (level, args)=>{
     logQueue.scheduleLogSend(entry);
 };
 const forwardErrorLog = (args)=>{
+    // Skip React server replayed logs - they were already logged on the server
+    if (isReactServerReplayedLog(args)) {
+        return;
+    }
     // Always log to client file logger with args (formatting done inside log method)
     clientFileLogger.log('error', args);
     // Only forward to terminal if enabled
@@ -344,7 +347,7 @@ const forwardErrorLog = (args)=>{
    * browser shows stack regardless of type of data passed to console.error, so we should do the same
    *
    * do not abstract this, it implicitly relies on which functions call it. forcing the inlined implementation makes you think about callers
-   */ const stack = stackWithOwners(new Error());
+   */ const stack = getErrorStack(new Error());
     const stackLines = stack?.split('\n');
     const cleanStack = stackLines?.slice(3).join('\n');
     const entry = {
@@ -372,12 +375,14 @@ const createUncaughtErrorEntry = (errorName, errorMessage, fullStack)=>{
     };
     logQueue.scheduleLogSend(entry);
 };
-const stackWithOwners = (error)=>{
-    let ownerStack = '';
-    (0, _stitchederror.setOwnerStackIfAvailable)(error);
-    ownerStack = (0, _stitchederror.getOwnerStack)(error) || '';
-    const stack = (error.stack || '') + ownerStack;
-    return stack;
+const getErrorStack = (error)=>{
+    return error.stack || '';
+};
+// Get error stack with owner stack appended for source mapping on the server
+const getErrorStackWithOwnerStack = (error)=>{
+    const errorStack = getErrorStack(error);
+    const ownerStack = (0, _stitchederror.getOwnerStack)(error);
+    return ownerStack ? `${errorStack}\n${ownerStack}` : errorStack;
 };
 function logUnhandledRejection(reason) {
     // Always log to client file logger
@@ -390,7 +395,7 @@ function logUnhandledRejection(reason) {
         return;
     }
     if (reason instanceof Error) {
-        createUnhandledRejectionErrorEntry(reason, stackWithOwners(reason));
+        createUnhandledRejectionErrorEntry(reason, getErrorStackWithOwnerStack(reason));
         return;
     }
     createUnhandledRejectionNonErrorEntry(reason);
@@ -462,7 +467,7 @@ function forwardUnhandledError(error) {
     if (!isTerminalLoggingEnabled) {
         return;
     }
-    createUncaughtErrorEntry(error.name, error.message, stackWithOwners(error));
+    createUncaughtErrorEntry(error.name, error.message, getErrorStackWithOwnerStack(error));
 }
 const initializeDebugLogForwarding = (router)=>{
     // probably don't need this

package/standalone/node_modules/next/dist/next-devtools/userspace/app/segment-explorer-node.js

@@ -40,6 +40,7 @@ _export(exports, {
 const _jsxruntime = require("react/jsx-runtime");
 const _react = require("react");
 const _nextdevtools = require("next/dist/compiled/next-devtools");
+const _approutercontextsharedruntime = require("../../../shared/lib/app-router-context.shared-runtime");
 const _notfound = require("../../../client/components/not-found");
 const SEGMENT_EXPLORER_SIMULATED_ERROR_MESSAGE = 'NEXT_DEVTOOLS_SIMULATED_ERROR';
 function SegmentTrieNode({ type, pagePath }) {
@@ -74,7 +75,7 @@ function NotFoundSegmentNode() {
 }
 function ErrorSegmentNode() {
     throw Object.defineProperty(new Error(SEGMENT_EXPLORER_SIMULATED_ERROR_MESSAGE), "__NEXT_ERROR_CODE", {
-        value: "E394",
+        value: "E716",
         enumerable: false,
         configurable: true
     });
@@ -85,13 +86,15 @@ function LoadingSegmentNode() {
     return null;
 }
 function SegmentViewStateNode({ page }) {
+    const { tree } = (0, _react.useContext)(_approutercontextsharedruntime.GlobalLayoutRouterContext);
     (0, _react.useLayoutEffect)(()=>{
-        _nextdevtools.dispatcher.segmentExplorerUpdateRouteState(page);
+        _nextdevtools.dispatcher.segmentExplorerUpdateRouteState(page, tree);
         return ()=>{
-            _nextdevtools.dispatcher.segmentExplorerUpdateRouteState('');
+            _nextdevtools.dispatcher.segmentExplorerUpdateRouteState('', null);
         };
     }, [
-        page
+        page,
+        tree
     ]);
     return null;
 }

package/standalone/node_modules/next/dist/server/app-render/action-handler.js

@@ -37,6 +37,8 @@ const _headers = require("../web/spec-extension/adapters/headers");
 const _utils1 = require("../web/utils");
 const _manifestssingleton = require("./manifests-singleton");
 const _helpers = require("../base-http/helpers");
+const _segmentexplorerpath = require("./segment-explorer-path");
+const _serverreferenceinfo = require("../../shared/lib/server-reference-info");
 const _redirectstatuscode = require("../../client/components/redirect-status-code");
 const _requeststore = require("../async-storage/request-store");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
@@ -50,6 +52,7 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+const INLINE_ACTION_PREFIX = '$$RSC_SERVER_ACTION_';
 /**
  * Checks if the app has any server actions defined in any runtime.
  */ function hasServerActions() {
@@ -105,7 +108,10 @@ function addRevalidationHeader(res, { workStore, requestStore }) {
     // 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;
+    // Only count tags without a profile (updateTag) as requiring client cache invalidation
+    // Tags with a profile (revalidateTag) use stale-while-revalidate and shouldn't
+    // trigger immediate client-side cache invalidation
+    const isTagRevalidated = ((_workStore_pendingRevalidatedTags = workStore.pendingRevalidatedTags) == null ? void 0 : _workStore_pendingRevalidatedTags.some((item)=>item.profile === undefined)) ? 1 : 0;
     const isCookieRevalidated = (0, _requestcookies.getModifiedCookieValues)(requestStore.mutableCookies).length ? 1 : 0;
     // First check if a tag, cookie, or path was revalidated.
     if (isTagRevalidated || isCookieRevalidated) {
@@ -374,7 +380,9 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
     // When running actions the default is no-store, you can still `cache: 'force-cache'`
     workStore.fetchCache = 'default-no-store';
     const originHeader = req.headers['origin'];
-    const originDomain = typeof originHeader === 'string' && originHeader !== 'null' ? new URL(originHeader).host : undefined;
+    const originHost = typeof originHeader === 'string' ? // However, these contexts can still send along credentials like cookies,
+    // so we need to check if they're allowed cross-origin requests.
+    originHeader === 'null' ? 'null' : new URL(originHeader).host : undefined;
     const host = parseHostHeader(req.headers);
     let warning = undefined;
     function warnBadServerActionRequest() {
@@ -384,20 +392,22 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
     }
     // This is to prevent CSRF attacks. If `x-forwarded-host` is set, we need to
     // ensure that the request is coming from the same host.
-    if (!originDomain) {
-        // This might be an old browser that doesn't send `host` header. We ignore
-        // this case.
+    if (!originHost) {
+        // This is a handcrafted request without an origin or a request from an unsafe browser.
+        // We'll let this through but log a warning.
+        // We can't guard against unsafe browsers and handcrafted requests can't contain
+        // user credentials that haven't been shared willingly.
         warning = 'Missing `origin` header from a forwarded Server Actions request.';
-    } else if (!host || originDomain !== host.value) {
+    } else if (!host || originHost !== host.value) {
         // If the customer sets a list of allowed origins, we'll allow the request.
         // These are considered safe but might be different from forwarded host set
         // by the infra (i.e. reverse proxies).
-        if ((0, _csrfprotection.isCsrfOriginAllowed)(originDomain, serverActions == null ? void 0 : serverActions.allowedOrigins)) {
+        if ((0, _csrfprotection.isCsrfOriginAllowed)(originHost, serverActions == null ? void 0 : serverActions.allowedOrigins)) {
         // Ignore it
         } else {
             if (host) {
                 // This seems to be an CSRF attack. We should not proceed the action.
-                console.error(`\`${host.type}\` header with value \`${limitUntrustedHeaderValueForLogs(host.value)}\` does not match \`origin\` header with value \`${limitUntrustedHeaderValueForLogs(originDomain)}\` from a forwarded Server Actions request. Aborting the action.`);
+                console.error(`\`${host.type}\` header with value \`${limitUntrustedHeaderValueForLogs(host.value)}\` does not match \`origin\` header with value \`${limitUntrustedHeaderValueForLogs(originHost)}\` from a forwarded Server Actions request. Aborting the action.`);
             } else {
                 // This is an attack. We should not proceed the action.
                 console.error(`\`x-forwarded-host\` or \`host\` headers are not provided. One of these is needed to compare the \`origin\` header from a forwarded Server Actions request. Aborting the action.`);
@@ -551,6 +561,10 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                 temporaryReferences = createTemporaryReferenceSet();
                 const { PassThrough, Readable, Transform } = require('node:stream');
                 const { pipeline } = require('node:stream/promises');
+                // If actionBody was stashed in request meta (from parsing the postponed
+                // state prefix in minimal mode), use it instead of req.body
+                const actionBodyFromMeta = (0, _requestmeta.getRequestMeta)(req, 'actionBody');
+                const body = actionBodyFromMeta ? Readable.from(actionBodyFromMeta) : req.body;
                 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
@@ -590,7 +604,7 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                         try {
                             ;
                             [, boundActionArguments] = await Promise.all([
-                                pipeline(req.body, sizeLimitTransform, busboy, {
+                                pipeline(body, sizeLimitTransform, busboy, {
                                     signal: abortController.signal
                                 }),
                                 decodeReplyFromBusboy(busboy, serverModuleMap, {
@@ -621,7 +635,7 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                         try {
                             ;
                             [, formData] = await Promise.all([
-                                pipeline(req.body, sizeLimitTransform, sizeLimitedBody, {
+                                pipeline(body, sizeLimitTransform, sizeLimitedBody, {
                                     signal: abortController.signal
                                 }),
                                 fakeRequest.formData()
@@ -678,7 +692,7 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
                     const sizeLimitedBody = new PassThrough();
                     const chunks = [];
                     await Promise.all([
-                        pipeline(req.body, sizeLimitTransform, sizeLimitedBody),
+                        pipeline(body, sizeLimitTransform, sizeLimitedBody),
                         (async ()=>{
                             for await (const chunk of sizeLimitedBody){
                                 chunks.push(Buffer.from(chunk));
@@ -709,24 +723,67 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
             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];
+            // Log server action call in development when enabled
+            let logInfo = null;
+            const { type: actionType } = (0, _serverreferenceinfo.extractInfoFromServerReferenceId)(actionId);
+            if (process.env.NODE_ENV === 'development' && ctx.renderOpts.logServerFunctions && // TODO: For now, skip logging for 'use cache' Server Functions as the
+            // output needs more work, or a different approach entirely.
+            actionType !== 'use-cache') {
+                var _serverActionsManifest_runtime;
+                const serverActionsManifest = (0, _manifestssingleton.getServerActionsManifest)();
+                const runtime = process.env.NEXT_RUNTIME === 'edge' ? 'edge' : 'node';
+                const actionInfo = (_serverActionsManifest_runtime = serverActionsManifest[runtime]) == null ? void 0 : _serverActionsManifest_runtime[actionId];
+                if (actionInfo) {
+                    var _actionInfo_exportedName;
+                    const isInlineAction = (_actionInfo_exportedName = actionInfo.exportedName) == null ? void 0 : _actionInfo_exportedName.startsWith(INLINE_ACTION_PREFIX);
+                    const projectDir = ctx.renderOpts.dir || (process.env.NEXT_RUNTIME === 'edge' ? '' : process.cwd());
+                    const location = (0, _segmentexplorerpath.normalizeFilePath)(projectDir, actionInfo.filename);
+                    // Format function name for display
+                    let functionName;
+                    if (isInlineAction) {
+                        functionName = '<inline action>';
+                    } else if (actionInfo.exportedName === 'default') {
+                        functionName = 'default';
+                    } else {
+                        functionName = actionInfo.exportedName || '<action>';
+                    }
+                    logInfo = {
+                        functionName,
+                        args: boundActionArguments,
+                        location
+                    };
+                }
+            }
+            const startTime = performance.now();
             const { actionResult, skipPageRendering } = await executeActionAndPrepareForRender(actionHandler, boundActionArguments, workStore, requestStore, actionWasForwarded).finally(()=>{
                 addRevalidationHeader(res, {
                     workStore,
                     requestStore
                 });
+                if (logInfo) {
+                    // Store server action log info to be logged after the request log
+                    const duration = Math.round(performance.now() - startTime);
+                    (0, _requestmeta.addRequestMeta)(req, 'devServerActionLog', {
+                        functionName: logInfo.functionName,
+                        args: logInfo.args,
+                        location: logInfo.location,
+                        duration
+                    });
+                }
             });
             // For form actions, we need to continue rendering the page.
             if (isFetchAction) {
+                // 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.
+                const maybeRevalidatesPromise = skipPageRendering ? (0, _revalidationutils.executeRevalidates)(workStore) : false;
                 return {
                     type: 'done',
                     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
+                        waitUntil: maybeRevalidatesPromise === false ? undefined : maybeRevalidatesPromise
                     })
                 };
             } else {
@@ -816,9 +873,20 @@ async function handleAction({ req, res, ComponentMod, generateFlight, workStore,
         throw err;
     }
 }
+/**
+ * Limit on the number of arguments passed to a server action. This prevents
+ * stack overflow during `action.apply()` from malicious requests.
+ */ const SERVER_ACTION_ARGS_LIMIT = 1000;
 async function executeActionAndPrepareForRender(action, args, workStore, requestStore, actionWasForwarded) {
     requestStore.phase = 'action';
     let skipPageRendering = actionWasForwarded;
+    if (args.length > SERVER_ACTION_ARGS_LIMIT) {
+        throw Object.defineProperty(new Error(`Server Action arguments list is too long (${args.length}). Maximum allowed is ${SERVER_ACTION_ARGS_LIMIT}.`), "__NEXT_ERROR_CODE", {
+            value: "E986",
+            enumerable: false,
+            configurable: true
+        });
+    }
     try {
         const actionResult = await _workunitasyncstorageexternal.workUnitAsyncStorage.run(requestStore, ()=>action.apply(null, args));
         // If the page was not revalidated, or if the action was forwarded from