failproofai 1.0.11-beta.1 → 1.0.11-beta.2

package/.next/standalone/node_modules/next/dist/build/utils.js

@@ -31,6 +31,7 @@ Object.defineProperty(exports, "__esModule", {
     isWebpackDefaultLayer: null,
     pageToRoute: null,
     printCustomRoutes: null,
+    printPrerenderMatchers: null,
     printTreeView: null,
     reduceAppConfig: null,
     shouldUseReactServerCondition: null,
@@ -127,6 +128,9 @@ _export(exports, {
     printCustomRoutes: function() {
         return printCustomRoutes;
     },
+    printPrerenderMatchers: function() {
+        return printPrerenderMatchers;
+    },
     printTreeView: function() {
         return printTreeView;
     },
@@ -140,7 +144,6 @@ _export(exports, {
         return unique;
     }
 });
-const _ppr = require("../server/lib/experimental/ppr");
 const _loadcustomroutes = require("../lib/load-custom-routes");
 const _constants = require("../lib/constants");
 require("../server/require-hook");
@@ -175,6 +178,7 @@ const _app1 = require("../shared/lib/router/routes/app");
 const _getmetadataroute = require("../lib/metadata/get-metadata-route");
 const _ismetadataroute = require("../lib/metadata/is-metadata-route");
 const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _nft = require("./nft");
 const _getsupportedbrowsers = require("./get-supported-browsers");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -237,11 +241,7 @@ function buildStaticMetadataStaticPaths(page) {
     }
     const prerenderPathname = (0, _getmetadataroute.getStaticMetadataPrerenderPathname)(pathname);
     if (!prerenderPathname) {
-        throw Object.defineProperty(new Error(`Invariant: expected static metadata route to have a prerender pathname (${page})`), "__NEXT_ERROR_CODE", {
-            value: "E1280",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant: expected static metadata route to have a prerender pathname (${page})`);
     }
     return {
         fallbackMode: undefined,
@@ -541,6 +541,62 @@ async function printTreeView(lists, pageInfos, { pagesDir, pageExtensions, middl
     }));
     print();
 }
+function countDynamicSegments(pathname) {
+    var _pathname_match;
+    return ((_pathname_match = pathname.match(/\[[^/]+\]/g)) == null ? void 0 : _pathname_match.length) ?? 0;
+}
+function printPrerenderMatchers(prerenderManifest, emittedDynamicRoutes) {
+    const sourceRoutes = new Set();
+    for (const route of Object.values(prerenderManifest.dynamicRoutes)){
+        if (route.fallbackSourceRoute) {
+            sourceRoutes.add(route.fallbackSourceRoute);
+        }
+    }
+    for (const route of Object.values(prerenderManifest.routes)){
+        if (route.srcRoute) {
+            sourceRoutes.add(route.srcRoute);
+        }
+    }
+    if (sourceRoutes.size === 0) return;
+    print((0, _picocolors.underline)('Experimental parameter matching'));
+    print('More-specific rows override broader rows for the same request.');
+    print();
+    for (const sourceRoute of [
+        ...sourceRoutes
+    ].sort()){
+        const matchers = Object.entries(prerenderManifest.dynamicRoutes).filter(([pathname, route])=>pathname === sourceRoute || route.fallbackSourceRoute === sourceRoute).map(([pathname, route])=>({
+                behavior: route.fallback === false ? 'not-found' : route.fallback === null ? 'blocking' : 'fallback',
+                pathname
+            })).sort((a, b)=>countDynamicSegments(b.pathname) - countDynamicSegments(a.pathname) || a.pathname.localeCompare(b.pathname));
+        const prerenders = Object.entries(prerenderManifest.routes).filter(([, route])=>route.srcRoute === sourceRoute).map(([pathname])=>({
+                behavior: 'prerender',
+                pathname
+            })).sort((a, b)=>a.pathname.localeCompare(b.pathname));
+        const entries = [
+            ...matchers,
+            ...prerenders
+        ];
+        const width = Math.max(...entries.map(({ behavior })=>behavior.length));
+        print(sourceRoute);
+        entries.forEach(({ behavior, pathname }, index)=>{
+            print(`  ${index === entries.length - 1 ? '└' : '├'} ${behavior.padEnd(width)}  ${pathname}`);
+        });
+        print();
+    }
+    print((0, _picocolors.underline)('Emitted dynamic route patterns'));
+    print('These are the patterns available to deployment routing metadata.');
+    print();
+    for (const sourceRoute of [
+        ...sourceRoutes
+    ].sort()){
+        const patterns = emittedDynamicRoutes.filter((route)=>route.page === sourceRoute || route.sourcePage === sourceRoute);
+        print(`${sourceRoute} (${patterns.length})`);
+        patterns.forEach((route, index)=>{
+            print(`  ${index === patterns.length - 1 ? '└' : '├'} ${route.page}`);
+        });
+        print();
+    }
+}
 function printCustomRoutes({ redirects, rewrites, headers, onMatchHeaders }) {
     const printRoutes = (routes, type)=>{
         const isRedirects = type === 'Redirects';
@@ -592,7 +648,7 @@ function printCustomRoutes({ redirects, rewrites, headers, onMatchHeaders }) {
         printRoutes(combinedRewrites, 'Rewrites');
     }
 }
-async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptions, locales, defaultLocale, parentId, pageRuntime, edgeInfo, pageType, cacheComponents, authInterrupts, useCacheTimeout, staticPageGenerationTimeout, originalAppPath, isrFlushToDisk, cacheMaxMemorySize, nextConfigOutput, cacheHandler, cacheHandlers, cacheLifeProfiles, pprConfig, buildId, deploymentId, clientAssetToken, sriEnabled }) {
+async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptions, locales, defaultLocale, parentId, pageRuntime, edgeInfo, pageType, cacheComponents, partialPrefetching, authInterrupts, useCacheTimeout, durableUseCacheEntries, staticPageGenerationTimeout, originalAppPath, isrFlushToDisk, cacheMaxMemorySize, nextConfigOutput, cacheHandler, cacheHandlers, cacheLifeProfiles, buildId, deploymentId, clientAssetToken, sriEnabled }) {
     // Skip page data collection for synthetic _global-error routes
     if (page === _constants1.UNDERSCORE_GLOBAL_ERROR_ROUTE) {
         return {
@@ -600,6 +656,8 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             isRoutePPREnabled: false,
             prerenderFallbackMode: undefined,
             prerenderedRoutes: undefined,
+            prerenderRouteMatchers: undefined,
+            paramMatching: undefined,
             rootParamKeys: undefined,
             hasStaticProps: false,
             hasServerProps: false,
@@ -622,6 +680,8 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
         });
         let componentsResult;
         let prerenderedRoutes;
+        let prerenderRouteMatchers;
+        let paramMatching;
         let prerenderFallbackMode;
         let appConfig = {};
         let rootParamKeys;
@@ -674,29 +734,29 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
         if (pageType === 'app') {
             // @ts-expect-error pageType is app, so we can assume AppPageModule | AppRouteModule
             const ComponentMod = componentsResult.ComponentMod;
-            let segments;
+            let collectedSegments;
             try {
-                segments = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we
+                collectedSegments = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we
                 // checked above that the page type is 'app'.
-                routeModule);
+                routeModule, {
+                    cacheComponents,
+                    partialPrefetching
+                });
             } catch (err) {
-                throw Object.defineProperty(new Error(`Failed to collect configuration for ${page}`, {
+                throw new Error(`Failed to collect configuration for ${page}`, {
                     cause: err
-                }), "__NEXT_ERROR_CODE", {
-                    value: "E434",
-                    enumerable: false,
-                    configurable: true
                 });
             }
+            const { segments, segmentTree } = collectedSegments;
             appConfig = originalAppPath === _constants1.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY ? {} : reduceAppConfig(segments);
             if (appConfig.dynamic === 'force-static' && pathIsEdgeRuntime) {
                 _log.warn(`Page "${page}" is using runtime = 'edge' which is currently incompatible with dynamic = 'force-static'. Please remove either "runtime" or "force-static" for correct behavior`);
             }
             rootParamKeys = (0, _collectrootparamkeys.collectRootParamKeys)(routeModule);
-            // A page supports partial prerendering if it is an app page and either
-            // the whole app has PPR enabled or this page has PPR enabled when we're
-            // in incremental mode.
-            isRoutePPREnabled = routeModule.definition.kind === _routekind.RouteKind.APP_PAGE && (0, _ppr.checkIsRoutePPREnabled)(pprConfig);
+            // A page supports partial prerendering when it is an app page and
+            // Cache Components is enabled.
+            isRoutePPREnabled = routeModule.definition.kind === _routekind.RouteKind.APP_PAGE && cacheComponents;
+            const isEnsureStaticPage = cacheComponents && isRoutePPREnabled && appConfig.ensureStatic === 'navigation';
             // If force dynamic was set and we don't have PPR enabled, then set the
             // revalidate to 0.
             // TODO: (PPR) remove this once PPR is enabled by default
@@ -717,15 +777,17 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
                     ({ prerenderedRoutes, fallbackMode: prerenderFallbackMode } = buildStaticMetadataStaticPaths(page));
                 } else {
                     ;
-                    ({ prerenderedRoutes, fallbackMode: prerenderFallbackMode } = await (0, _app.buildAppStaticPaths)({
+                    ({ prerenderedRoutes, prerenderRouteMatchers, paramMatching, fallbackMode: prerenderFallbackMode } = await (0, _app.buildAppStaticPaths)({
                         dir,
                         page,
                         route,
                         cacheComponents,
                         authInterrupts,
                         useCacheTimeout,
+                        durableUseCacheEntries,
                         staticPageGenerationTimeout,
                         segments,
+                        segmentTree,
                         distDir,
                         requestHeaders: {},
                         isrFlushToDisk,
@@ -735,6 +797,7 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
                         ComponentMod,
                         nextConfigOutput,
                         isRoutePPREnabled,
+                        isEnsureStaticPage,
                         buildId,
                         deploymentId,
                         rootParamKeys
@@ -743,11 +806,7 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             }
         } else {
             if (!Comp || !(0, _reactis.isValidElementType)(Comp) || typeof Comp === 'string') {
-                throw Object.defineProperty(new Error('INVALID_DEFAULT_EXPORT'), "__NEXT_ERROR_CODE", {
-                    value: "E457",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('INVALID_DEFAULT_EXPORT');
             }
         }
         const hasGetInitialProps = !!(Comp == null ? void 0 : Comp.getInitialProps);
@@ -757,41 +816,21 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
         // A page cannot be prerendered _and_ define a data requirement. That's
         // contradictory!
         if (hasGetInitialProps && hasStaticProps) {
-            throw Object.defineProperty(new Error(_constants.SSG_GET_INITIAL_PROPS_CONFLICT), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(_constants.SSG_GET_INITIAL_PROPS_CONFLICT);
         }
         if (hasGetInitialProps && hasServerProps) {
-            throw Object.defineProperty(new Error(_constants.SERVER_PROPS_GET_INIT_PROPS_CONFLICT), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(_constants.SERVER_PROPS_GET_INIT_PROPS_CONFLICT);
         }
         if (hasStaticProps && hasServerProps) {
-            throw Object.defineProperty(new Error(_constants.SERVER_PROPS_SSG_CONFLICT), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(_constants.SERVER_PROPS_SSG_CONFLICT);
         }
         const pageIsDynamic = (0, _isdynamic.isDynamicRoute)(page);
         // A page cannot have static parameters if it is not a dynamic page.
         if (hasStaticProps && hasStaticPaths && !pageIsDynamic) {
-            throw Object.defineProperty(new Error(`getStaticPaths can only be used with dynamic pages, not '${page}'.` + `\nLearn more: https://nextjs.org/docs/routing/dynamic-routes`), "__NEXT_ERROR_CODE", {
-                value: "E356",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`getStaticPaths can only be used with dynamic pages, not '${page}'.` + `\nLearn more: https://nextjs.org/docs/routing/dynamic-routes`);
         }
         if (hasStaticProps && pageIsDynamic && !hasStaticPaths) {
-            throw Object.defineProperty(new Error(`getStaticPaths is required for dynamic SSG pages and is missing for '${page}'.` + `\nRead more: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`), "__NEXT_ERROR_CODE", {
-                value: "E255",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`getStaticPaths is required for dynamic SSG pages and is missing for '${page}'.` + `\nRead more: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`);
         }
         if (hasStaticProps && hasStaticPaths) {
             ;
@@ -818,6 +857,8 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             isRoutePPREnabled,
             prerenderFallbackMode,
             prerenderedRoutes,
+            prerenderRouteMatchers,
+            paramMatching,
             rootParamKeys,
             hasStaticProps,
             hasServerProps,
@@ -829,17 +870,13 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             throw err;
         }
         console.error(err);
-        throw Object.defineProperty(new Error(`Failed to collect page data for ${page}`), "__NEXT_ERROR_CODE", {
-            value: "E414",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Failed to collect page data for ${page}`);
     });
 }
 function reduceAppConfig(segments) {
     const config = {};
     for (const segment of segments){
-        const { dynamic, fetchCache, preferredRegion, revalidate, runtime, maxDuration } = segment.config || {};
+        const { dynamic, fetchCache, preferredRegion, revalidate, runtime, maxDuration, prefetch, ensureStatic } = segment.config || {};
         // TODO: should conflicting configs here throw an error
         // e.g. if layout defines one region but page defines another
         if (typeof preferredRegion !== 'undefined') {
@@ -865,6 +902,14 @@ function reduceAppConfig(segments) {
         if (typeof maxDuration !== 'undefined') {
             config.maxDuration = maxDuration;
         }
+        // These two should be set uniformly across all segments
+        // in `collectAppPageSegments`, but we need to forward them here.
+        if (typeof prefetch !== 'undefined') {
+            config.prefetch = prefetch;
+        }
+        if (typeof ensureStatic !== 'undefined') {
+            config.ensureStatic = ensureStatic;
+        }
     }
     return config;
 }
@@ -994,45 +1039,80 @@ async function copyTracedFiles(dir, distDir, pageKeys, appPageKeys, tracingRoot,
         await _fs.promises.writeFile(packageJsonOutputPath, packageJsonContent);
     } catch  {}
     const copiedFiles = new Set();
+    const skippedTraceFiles = new Set();
+    async function createTracedSymlink(target, linkPath, sourcePath) {
+        let isDirectory = false;
+        if (process.platform === 'win32') {
+            // Windows requires the target type when creating a symlink. Files are
+            // copied in an arbitrary order, so the target might not exist in the
+            // output yet. Inspect the original target through the source symlink
+            // instead.
+            try {
+                isDirectory = (await _fs.promises.stat(sourcePath)).isDirectory();
+            } catch (err) {
+                if (err.code !== 'ENOENT' && err.code !== 'ELOOP') {
+                    throw err;
+                }
+            }
+        }
+        try {
+            // the target type argument is ignored on non-windows platforms
+            await _fs.promises.symlink(target, linkPath, isDirectory ? 'dir' : 'file');
+        } catch (err) {
+            // Windows doesn't support creating symlinks without elevated privileges,
+            // unless "Developer Mode" is turned on. If we failed to create a symlink
+            // due to EPERM, try creating a junction point instead.
+            //
+            // Ideally we'd just preserve the input file type (junction point or
+            // symlink), but there's no API in node.js to differentiate between a
+            // junction point and a symlink, so we just try making a symlink first.
+            // Symlinks are preferred because they support relative paths and
+            // non-directory (file) targets.
+            //
+            // Note: Junction targets are stored as absolute paths, so this fallback
+            // is not relocatable even when the preferred symlink above is relative,
+            // but it's the best we can do.
+            if (process.platform === 'win32' && err.code === 'EPERM' && isDirectory) {
+                try {
+                    await _fs.promises.symlink(_path.default.resolve(_path.default.dirname(linkPath), target), linkPath, 'junction');
+                } catch (junctionErr) {
+                    if (junctionErr.code !== 'EEXIST') {
+                        throw junctionErr;
+                    }
+                }
+            } else if (err.code !== 'EEXIST') {
+                throw err;
+            }
+        }
+    }
     async function handleTraceFiles(traceFilePath) {
         const traceData = JSON.parse(await _fs.promises.readFile(/* turbopackIgnore: true */ traceFilePath, 'utf8'));
+        const entries = (0, _nft.mapNftFileEntries)(traceData, traceFilePath, tracingRoot, {
+            skipBaseRootEscapes: true,
+            onBaseRootEscape: (source)=>skippedTraceFiles.add(source)
+        });
         const copySema = new _asyncsema.Sema(10, {
-            capacity: traceData.files.length
+            capacity: entries.length
         });
-        const traceFileDir = _path.default.dirname(traceFilePath);
-        await Promise.all(traceData.files.map(async (relativeFile)=>{
+        await Promise.all(entries.map(async (entry)=>{
             await copySema.acquire();
-            const tracedFilePath = _path.default.join(traceFileDir, relativeFile);
-            const fileOutputPath = _path.default.join(outputPath, _path.default.relative(tracingRoot, tracedFilePath));
+            const tracedFilePath = entry.source;
+            const fileOutputPath = (0, _nft.resolveNftOutputPath)(outputPath, entry.destination);
             if (!copiedFiles.has(fileOutputPath)) {
                 copiedFiles.add(fileOutputPath);
                 await _fs.promises.mkdir(_path.default.dirname(fileOutputPath), {
                     recursive: true
                 });
-                const symlink = await _fs.promises.readlink(tracedFilePath).catch(()=>null);
-                if (symlink) {
-                    try {
-                        await _fs.promises.symlink(symlink, fileOutputPath);
-                    } catch (err) {
-                        // Windows doesn't support creating symlinks without elevated privileges, unless
-                        // "Developer Mode" is turned on. If we failed to create a symlink due to EPERM, try
-                        // creating a junction point instead.
-                        //
-                        // Ideally we'd just preserve the input file type (junction point or symlink), but
-                        // there's no API in node.js to differentiate between a junction point and a symlink,
-                        // so we just try making a symlink first. Symlinks are preferred because they support
-                        // relative paths and non-directory (file) targets.
-                        if (process.platform === 'win32' && err.code === 'EPERM' && _path.default.isAbsolute(symlink)) {
-                            try {
-                                await _fs.promises.symlink(symlink, fileOutputPath, 'junction');
-                            } catch (junctionErr) {
-                                if (junctionErr.code !== 'EEXIST') {
-                                    throw junctionErr;
-                                }
-                            }
-                        } else if (err.code !== 'EEXIST') {
-                            throw err;
-                        }
+                if (entry.symlinkTarget !== undefined) {
+                    const targetOutputPath = (0, _nft.resolveNftOutputPath)(outputPath, entry.symlinkTarget);
+                    const target = _path.default.relative(_path.default.dirname(fileOutputPath), targetOutputPath) || '.';
+                    await createTracedSymlink(target, fileOutputPath, tracedFilePath);
+                } else if (traceData.symlinks === undefined) {
+                    const target = await _fs.promises.readlink(tracedFilePath).catch(()=>null);
+                    if (target) {
+                        await createTracedSymlink(target, fileOutputPath, tracedFilePath);
+                    } else {
+                        await _fs.promises.copyFile(tracedFilePath, fileOutputPath);
                     }
                 } else {
                     await _fs.promises.copyFile(tracedFilePath, fileOutputPath);
@@ -1152,6 +1232,21 @@ startServer({
   console.error(err);
   process.exit(1);
 });`);
+    if (skippedTraceFiles.size > 0) {
+        const count = skippedTraceFiles.size;
+        const skippedFilesOutput = [
+            ...skippedTraceFiles
+        ].slice(0, 100).map((file)=>`  - ${_path.default.relative(tracingRoot, file)}`).join('\n');
+        const warning = [
+            `${count} traced files were not included in the standalone output`,
+            'because their paths are outside of `outputFileTracingRoot`.',
+            'First 100 skipped files:',
+            skippedFilesOutput,
+            'Set `outputFileTracingRoot` to a common parent directory',
+            'to include these files.'
+        ].join('\n');
+        _log.warn(warning);
+    }
 }
 function isReservedPage(page) {
     return RESERVED_PAGE.test(page);
@@ -1187,11 +1282,6 @@ function getPossibleMiddlewareFilenames(folder, extensions) {
 class NestedMiddlewareError extends Error {
     constructor(nestedFileNames, mainDir, pagesOrAppDir){
         super(`Nested Middleware is not allowed, found:\n` + `${nestedFileNames.map((file)=>`pages${file}`).join('\n')}\n` + `Please move your code to a single file at ${_path.default.join(_path.default.posix.sep, _path.default.relative(mainDir, _path.default.resolve(pagesOrAppDir, '..')), 'middleware')} instead.\n` + `Read More - https://nextjs.org/docs/messages/nested-middleware`);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E1173",
-            enumerable: false,
-            configurable: true
-        });
     }
 }
 function shouldUseReactServerCondition(layer) {

package/.next/standalone/node_modules/next/dist/cli/next-test.js

@@ -22,6 +22,7 @@ _export(exports, {
 });
 const _fs = require("fs");
 const _getprojectdir = require("../lib/get-project-dir");
+const _warnmissingreactdependencies = require("../lib/warn-missing-react-dependencies");
 const _utils = require("../server/lib/utils");
 const _config = /*#__PURE__*/ _interop_require_default(require("../server/config"));
 const _constants = require("../shared/lib/constants");
@@ -78,6 +79,9 @@ async function nextTest(directory, testRunnerArgs = [], options = {}) {
         nextConfig = await (0, _config.default)(_constants.PHASE_PRODUCTION_BUILD, baseDir) // let this error bubble up if the `basePath` is still not a valid Next.js project
         ;
     }
+    // The directory may have been a runner argument; check the app only after
+    // the fallback above has resolved its actual project directory.
+    (0, _warnmissingreactdependencies.warnMissingReactDependencies)(baseDir);
     // set the test runner. priority is CLI option > next config > default 'playwright'
     const configuredTestRunner = (options == null ? void 0 : options.testRunner) ?? // --test-runner='foo'
     nextConfig.experimental.defaultTestRunner ?? // { experimental: { defaultTestRunner: 'foo' }}

package/.next/standalone/node_modules/next/dist/client/app-call-server.js

@@ -1,29 +1,27 @@
-"use strict";
+// The entry point for Server Actions: the "action door" into the router.
+// Server Actions are deliberately not a navigator operation (navigator.ts) —
+// the action queue is semantically separate from the router state queue —
+// but this module forks the same way: by default it re-exports the
+// sequential implementation, and when `experimental.concurrentRouterQueue`
+// is enabled, imports of this module resolve to './concurrent-call-server'
+// instead at the bundler level (see create-compiler-aliases.ts and
+// next_import_map.rs). Both implementations expose exactly this surface.
+/**
+ * Invoke a Server Action. The returned promise resolves with the action's
+ * return value once the response has been processed. Navigation and
+ * revalidation side effects of the action are handled by the router; they are
+ * not observable through the returned promise.
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
 Object.defineProperty(exports, "callServer", {
     enumerable: true,
     get: function() {
-        return callServer;
+        return _sequentialcallserver.callServer;
     }
 });
-const _react = require("react");
-const _routerreducertypes = require("./components/router-reducer/router-reducer-types");
-const _useactionqueue = require("./components/use-action-queue");
-async function callServer(actionId, actionArgs) {
-    return new Promise((resolve, reject)=>{
-        (0, _react.startTransition)(()=>{
-            (0, _useactionqueue.dispatchAppRouterAction)({
-                type: _routerreducertypes.ACTION_SERVER_ACTION,
-                actionId,
-                actionArgs,
-                resolve,
-                reject
-            });
-        });
-    });
-}
+const _sequentialcallserver = require("./sequential-call-server");
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });