@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.4

package/assets/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/assets/standalone/node_modules/next/dist/lib/worker.js

@@ -74,13 +74,14 @@ class Worker {
             delete nodeOptions['max-old-space-size'];
             delete nodeOptions['max_old_space_size'];
         }
+        const { nodeOptions: formattedNodeOptions, execArgv } = (0, _utils.formatNodeOptions)(nodeOptions);
         const createWorker = ()=>{
-            var _farmOptions_forkOptions;
+            var _farmOptions_forkOptions, _farmOptions_forkOptions1;
             const workerEnv = {
                 ...process.env,
                 ...((_farmOptions_forkOptions = farmOptions.forkOptions) == null ? void 0 : _farmOptions_forkOptions.env) || {},
                 IS_NEXT_WORKER: 'true',
-                NODE_OPTIONS: (0, _utils.formatNodeOptions)(nodeOptions)
+                NODE_OPTIONS: formattedNodeOptions
             };
             if (workerEnv.FORCE_COLOR === undefined) {
                 var _process_stderr;
@@ -98,6 +99,10 @@ class Worker {
                 ...farmOptions,
                 forkOptions: {
                     ...farmOptions.forkOptions,
+                    execArgv: [
+                        ...execArgv,
+                        ...((_farmOptions_forkOptions1 = farmOptions.forkOptions) == null ? void 0 : _farmOptions_forkOptions1.execArgv) || []
+                    ],
                     env: workerEnv
                 },
                 maxRetries: 0
@@ -169,26 +174,32 @@ class Worker {
             if (this._onActivity) this._onActivity();
             hangingTimer = activeTasks > 0 && setTimeout(onHanging, timeout);
         };
+        // TODO: Remove this once callers stop passing non-serializable values
+        // (e.g. functions) in worker method arguments. The structured clone
+        // algorithm used by worker_threads rejects functions, unlike
+        // child_process which silently drops them via JSON serialization.
+        const sanitizeArgs = farmOptions.enableWorkerThreads ? (args)=>JSON.parse(JSON.stringify(args)) : (args)=>args;
         for (const method of farmOptions.exposedMethods){
             if (method.startsWith('_')) continue;
             this[method] = timeout ? async (...args)=>{
                 activeTasks++;
+                const sanitizedArgs = sanitizeArgs(args);
                 try {
                     let attempts = 0;
                     for(;;){
                         onActivityImpl();
                         const result = await Promise.race([
-                            this._worker[method](...args),
+                            this._worker[method](...sanitizedArgs),
                             restartPromise
                         ]);
                         if (result !== RESTARTED) return result;
-                        if (onRestart) onRestart(method, args, ++attempts);
+                        if (onRestart) onRestart(method, sanitizedArgs, ++attempts);
                     }
                 } finally{
                     activeTasks--;
                     onActivityImpl();
                 }
-            } : this._worker[method].bind(this._worker);
+            } : (...args)=>this._worker[method](...sanitizeArgs(args));
         }
     }
     setOnActivity(onActivity) {

package/assets/standalone/node_modules/next/dist/server/api-utils/node/api-resolver.js

@@ -207,7 +207,7 @@ async function revalidate(urlPath, opts, req, context) {
             configurable: true
         });
     }
-    const revalidateHeaders = {
+    const headers = {
         [_constants.PRERENDER_REVALIDATE_HEADER]: context.previewModeId,
         ...opts.unstable_onlyGenerated ? {
             [_constants.PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER]: '1'
@@ -224,7 +224,7 @@ async function revalidate(urlPath, opts, req, context) {
     }
     for (const key of Object.keys(req.headers)){
         if (allowedRevalidateHeaderKeys.includes(key)) {
-            revalidateHeaders[key] = req.headers[key];
+            headers[key] = req.headers[key];
         }
     }
     const internalRevalidate = context.internalRevalidate;
@@ -235,14 +235,14 @@ async function revalidate(urlPath, opts, req, context) {
         if (internalRevalidate) {
             return await internalRevalidate({
                 urlPath,
-                revalidateHeaders,
+                headers,
                 opts
             });
         }
         if (context.trustHostHeader) {
             const res = await fetch(`https://${req.headers.host}${urlPath}`, {
                 method: 'HEAD',
-                headers: revalidateHeaders
+                headers
             });
             // we use the cache header to determine successful revalidate as
             // a non-200 status code can be returned from a successful revalidate

package/assets/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

package/assets/standalone/node_modules/next/dist/server/app-render/app-render-prerender-utils.js

@@ -7,8 +7,6 @@ Object.defineProperty(exports, "__esModule", {
     ReactServerResult: null,
     createReactServerPrerenderResult: null,
     createReactServerPrerenderResultFromRender: null,
-    prerenderAndAbortInSequentialTasks: null,
-    prerenderAndAbortInSequentialTasksWithStages: null,
     processPrelude: null
 });
 function _export(target, all) {
@@ -30,91 +28,11 @@ _export(exports, {
     createReactServerPrerenderResultFromRender: function() {
         return createReactServerPrerenderResultFromRender;
     },
-    prerenderAndAbortInSequentialTasks: function() {
-        return prerenderAndAbortInSequentialTasks;
-    },
-    prerenderAndAbortInSequentialTasksWithStages: function() {
-        return prerenderAndAbortInSequentialTasksWithStages;
-    },
     processPrelude: function() {
         return processPrelude;
     }
 });
 const _invarianterror = require("../../shared/lib/invariant-error");
-const _apprenderscheduling = require("./app-render-scheduling");
-const _fastsetimmediateexternal = require("../node-environment-extensions/fast-set-immediate.external");
-function prerenderAndAbortInSequentialTasks(prerender, abort) {
-    if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasks` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E538",
-            enumerable: false,
-            configurable: true
-        });
-    } else {
-        return new Promise((resolve, reject)=>{
-            const scheduleTimeout = (0, _apprenderscheduling.createAtomicTimerGroup)();
-            let pendingResult;
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    pendingResult = prerender();
-                    pendingResult.catch(()=>{});
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.expectNoPendingImmediates)();
-                    abort();
-                    resolve(pendingResult);
-                } catch (err) {
-                    reject(err);
-                }
-            });
-        });
-    }
-}
-function prerenderAndAbortInSequentialTasksWithStages(prerender, advanceStage, abort) {
-    if (process.env.NEXT_RUNTIME === 'edge') {
-        throw Object.defineProperty(new _invarianterror.InvariantError('`prerenderAndAbortInSequentialTasksWithStages` should not be called in edge runtime.'), "__NEXT_ERROR_CODE", {
-            value: "E778",
-            enumerable: false,
-            configurable: true
-        });
-    } else {
-        return new Promise((resolve, reject)=>{
-            const scheduleTimeout = (0, _apprenderscheduling.createAtomicTimerGroup)();
-            let pendingResult;
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    pendingResult = prerender();
-                    pendingResult.catch(()=>{});
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.DANGEROUSLY_runPendingImmediatesAfterCurrentTask)();
-                    advanceStage();
-                } catch (err) {
-                    reject(err);
-                }
-            });
-            scheduleTimeout(()=>{
-                try {
-                    (0, _fastsetimmediateexternal.expectNoPendingImmediates)();
-                    abort();
-                    resolve(pendingResult);
-                } catch (err) {
-                    reject(err);
-                }
-            });
-        });
-    }
-}
 class ReactServerResult {
     constructor(stream){
         this._stream = stream;