@modern-js/app-tools 3.0.0-beta.0 → 3.0.0

package/dist/cjs/plugins/deploy/platforms/vercel.js

@@ -0,0 +1,176 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createVercelPreset: ()=>createVercelPreset
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const external_ndepe_namespaceObject = require("ndepe");
+const routes_js_namespaceObject = require("../../../utils/routes.js");
+const external_utils_js_namespaceObject = require("../utils.js");
+const createVercelPreset = (appContext, modernConfig, needModernServer)=>{
+    const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType, metaName } = appContext;
+    const isEsmProject = 'module' === moduleType;
+    const plugins = serverPlugins.map((plugin)=>[
+            plugin.name,
+            plugin.options
+        ]);
+    const vercelOutput = external_node_path_default().join(appDirectory, '.vercel');
+    const outputDirectory = external_node_path_default().join(vercelOutput, 'output');
+    const funcsDirectory = external_node_path_default().join(outputDirectory, 'functions', 'index.func');
+    const entryFilePath = external_node_path_default().join(funcsDirectory, 'index.js');
+    const handlerFilePath = external_node_path_default().join(funcsDirectory, 'vercel-handler.cjs');
+    return {
+        async prepare () {
+            await utils_namespaceObject.fs.remove(vercelOutput);
+        },
+        async writeOutput () {
+            const config = {
+                version: 3,
+                routes: [
+                    {
+                        src: '/static/(.*)',
+                        headers: {
+                            'cache-control': 's-maxage=31536000, immutable'
+                        },
+                        continue: true
+                    },
+                    {
+                        handle: 'filesystem'
+                    }
+                ]
+            };
+            if (needModernServer) config.routes.push({
+                src: '/(.*)',
+                dest: "/index"
+            });
+            else {
+                const { source: { mainEntryName }, html: { outputStructure } } = modernConfig;
+                entrypoints.forEach((entry)=>{
+                    const isMain = (0, routes_js_namespaceObject.isMainEntry)(entry.entryName, mainEntryName);
+                    const htmlPath = 'flat' === outputStructure ? `/html/${entry.entryName}.html` : `/html/${entry.entryName}/index.html`;
+                    config.routes.push({
+                        src: `/${isMain ? '' : entry.entryName}(?:/.*)?`,
+                        headers: {
+                            'cache-control': 's-maxage=0'
+                        },
+                        dest: htmlPath
+                    });
+                });
+            }
+            await utils_namespaceObject.fs.ensureDir(outputDirectory);
+            await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, 'config.json'), config, {
+                spaces: 2
+            });
+            const staticDirectory = external_node_path_default().join(outputDirectory, 'static/static');
+            await utils_namespaceObject.fs.copy(external_node_path_default().join(distDirectory, 'static'), staticDirectory);
+            if (needModernServer) {
+                await utils_namespaceObject.fs.ensureDir(funcsDirectory);
+                await utils_namespaceObject.fs.copy(distDirectory, funcsDirectory, {
+                    filter: (src)=>{
+                        const distStaticDirectory = external_node_path_default().join(distDirectory, 'static');
+                        return !src.includes(distStaticDirectory);
+                    }
+                });
+                const nodeVersion = process.versions.node.split('.')[0];
+                await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(funcsDirectory, '.vc-config.json'), {
+                    runtime: `nodejs${nodeVersion}.x`,
+                    handler: 'index.js',
+                    launcherType: 'Nodejs',
+                    shouldAddHelpers: false,
+                    supportsResponseStreaming: true
+                });
+            } else {
+                const destHtmlDirectory = external_node_path_default().join(distDirectory, 'html');
+                const outputHtmlDirectory = external_node_path_default().join(external_node_path_default().join(outputDirectory, 'static'), 'html');
+                await utils_namespaceObject.fs.copy(destHtmlDirectory, outputHtmlDirectory);
+            }
+        },
+        async genEntry () {
+            if (!needModernServer) return;
+            const serverConfig = {
+                bff: {
+                    prefix: modernConfig?.bff?.prefix
+                },
+                output: {
+                    distPath: {
+                        root: '.'
+                    }
+                }
+            };
+            const pluginImportCode = (0, external_utils_js_namespaceObject.genPluginImportsCode)(plugins || []);
+            const dynamicProdOptions = {
+                config: serverConfig
+            };
+            const meta = (0, utils_namespaceObject.getMeta)(metaName);
+            const serverConfigPath = `path.join(__dirname, "${utils_namespaceObject.SERVER_DIR}", "${meta}.server")`;
+            const pluginsCode = (0, external_utils_js_namespaceObject.getPluginsCode)(plugins || []);
+            const serverAppContext = (0, external_utils_js_namespaceObject.serverAppContenxtTemplate)(appContext);
+            let handlerCode = (await utils_namespaceObject.fs.readFile(external_node_path_default().join(__dirname, './vercel-handler.js'))).toString();
+            handlerCode = handlerCode.replace('p_genPluginImportsCode', pluginImportCode).replace('p_ROUTE_SPEC_FILE', `"${utils_namespaceObject.ROUTE_SPEC_FILE}"`).replace('p_dynamicProdOptions', JSON.stringify(dynamicProdOptions)).replace('p_plugins', pluginsCode).replace('p_serverDirectory', serverConfigPath).replace('p_sharedDirectory', serverAppContext.sharedDirectory).replace('p_apiDirectory', serverAppContext.apiDirectory).replace('p_lambdaDirectory', serverAppContext.lambdaDirectory);
+            await utils_namespaceObject.fs.writeFile(handlerFilePath, handlerCode);
+            if (isEsmProject) await utils_namespaceObject.fs.copy(external_node_path_default().join(__dirname, './vercel-entry.mjs'), entryFilePath);
+            else await utils_namespaceObject.fs.copy(external_node_path_default().join(__dirname, './vercel-entry.js'), entryFilePath);
+        },
+        async end () {
+            if (!needModernServer) return;
+            await (0, external_ndepe_namespaceObject.nodeDepEmit)({
+                appDir: appDirectory,
+                sourceDir: funcsDirectory,
+                includeEntries: [
+                    require.resolve('@modern-js/prod-server')
+                ],
+                copyWholePackage (pkgName) {
+                    return '@modern-js/utils' === pkgName;
+                },
+                transformPackageJson: ({ pkgJSON })=>{
+                    if (!pkgJSON.exports || 'object' != typeof pkgJSON.exports) return pkgJSON;
+                    return {
+                        ...pkgJSON,
+                        exports: (0, utils_namespaceObject.removeModuleSyncFromExports)(pkgJSON.exports)
+                    };
+                }
+            });
+        }
+    };
+};
+exports.createVercelPreset = __webpack_exports__.createVercelPreset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createVercelPreset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/deploy/utils.js

@@ -0,0 +1,92 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getProjectUsage: ()=>getProjectUsage,
+    serverAppContenxtTemplate: ()=>serverAppContenxtTemplate,
+    getPluginsCode: ()=>getPluginsCode,
+    genPluginImportsCode: ()=>genPluginImportsCode
+});
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const serverAppContenxtTemplate = (appContext)=>{
+    const { appDirectory, sharedDirectory, apiDirectory, lambdaDirectory, metaName, bffRuntimeFramework } = appContext;
+    return {
+        sharedDirectory: `path.join(__dirname, "${external_path_default().relative(appDirectory, sharedDirectory)}")`,
+        apiDirectory: `path.join(__dirname, "${external_path_default().relative(appDirectory, apiDirectory)}")`,
+        lambdaDirectory: `path.join(__dirname, "${external_path_default().relative(appDirectory, lambdaDirectory)}")`,
+        metaName,
+        bffRuntimeFramework: bffRuntimeFramework || 'hono'
+    };
+};
+const genPluginImportsCode = (plugins)=>plugins.map(([name, options], index)=>`
+      let plugin_${index} = require('${name}')
+      plugin_${index} = plugin_${index}.default || plugin_${index}
+      `).join(';\n');
+const getPluginsCode = (plugins)=>`[${plugins.map(([, options], index)=>`plugin_${index}(${options ? JSON.stringify(options) : ''})`).join(',')}]`;
+const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
+    const routeJSON = external_path_default().join(distDirectory, utils_namespaceObject.ROUTE_SPEC_FILE);
+    const { routes } = utils_namespaceObject.fs.readJSONSync(routeJSON);
+    let useSSR = false;
+    let useAPI = false;
+    routes.forEach((route)=>{
+        if (route.isSSR) useSSR = true;
+        if (route.isApi) useAPI = true;
+    });
+    const meta = (0, utils_namespaceObject.getMeta)(metaName);
+    const serverConfigPath = external_path_default().resolve(appDirectory, utils_namespaceObject.SERVER_DIR, `${meta}.server`);
+    const isServerConfigExists = [
+        '.ts',
+        '.js'
+    ].some((ex)=>utils_namespaceObject.fs.existsSync(`${serverConfigPath}${ex}`));
+    return {
+        useSSR,
+        useAPI,
+        useWebServer: isServerConfigExists
+    };
+};
+exports.genPluginImportsCode = __webpack_exports__.genPluginImportsCode;
+exports.getPluginsCode = __webpack_exports__.getPluginsCode;
+exports.getProjectUsage = __webpack_exports__.getProjectUsage;
+exports.serverAppContenxtTemplate = __webpack_exports__.serverAppContenxtTemplate;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "genPluginImportsCode",
+    "getPluginsCode",
+    "getProjectUsage",
+    "serverAppContenxtTemplate"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/initialize/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>initialize
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("../../config/index.js");
+const initialize = ()=>({
+        name: '@modern-js/plugin-initialize',
+        post: [
+            '@modern-js/plugin-ssr',
+            '@modern-js/plugin-document',
+            '@modern-js/plugin-router',
+            '@modern-js/plugin-polyfill'
+        ],
+        setup (api) {
+            api.config(()=>{
+                const appContext = api.getAppContext();
+                return (0, index_js_namespaceObject.createDefaultConfig)(appContext);
+            });
+            api.modifyResolvedConfig(async (resolved)=>{
+                let appContext = api.getAppContext();
+                const userConfig = api.getConfig();
+                const port = await getServerPort(resolved);
+                appContext = {
+                    ...appContext,
+                    port,
+                    distDirectory: (0, utils_namespaceObject.ensureAbsolutePath)(appContext.appDirectory, resolved.output.distPath?.root || 'dist')
+                };
+                api.updateAppContext(appContext);
+                const normalizedConfig = resolved;
+                resolved._raw = userConfig;
+                resolved.server = {
+                    ...normalizedConfig.server || {},
+                    port
+                };
+                stabilizeConfig(resolved, normalizedConfig, [
+                    'source',
+                    'bff',
+                    'dev',
+                    'html',
+                    'output',
+                    'tools',
+                    'testing',
+                    'plugins',
+                    'builderPlugins',
+                    'deploy',
+                    'performance'
+                ]);
+                return resolved;
+            });
+        }
+    });
+function stabilizeConfig(resolve, config, keys) {
+    keys.forEach((key)=>{
+        resolve[key] = config[key] || {};
+    });
+}
+async function getServerPort(config) {
+    const prodPort = Number(process.env.PORT) || config.server.port || 8080;
+    if ((0, utils_namespaceObject.isDev)() && (0, utils_namespaceObject.isDevCommand)()) return (0, utils_namespaceObject.getPort)(Number(process.env.PORT) || prodPort);
+    return prodPort;
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/serverBuild.js

@@ -0,0 +1,91 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>serverBuild
+});
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const server_utils_namespaceObject = require("@modern-js/server-utils");
+const utils_namespaceObject = require("@modern-js/utils");
+const TS_CONFIG_FILENAME = 'tsconfig.json';
+function checkHasCache(appDir) {
+    const tsFilepath = external_path_default().resolve(appDir, utils_namespaceObject.SERVER_DIR, 'cache.ts');
+    const jsfilepath = external_path_default().resolve(appDir, utils_namespaceObject.SERVER_DIR, 'cache.js');
+    return external_fs_default().existsSync(tsFilepath) || external_fs_default().existsSync(jsfilepath);
+}
+function checkHasConfig(appDir, metaName = 'modern-js') {
+    const meta = (0, utils_namespaceObject.getMeta)(metaName);
+    const tsFilepath = external_path_default().resolve(appDir, utils_namespaceObject.SERVER_DIR, `${meta}.server.ts`);
+    const jsfilepath = external_path_default().resolve(appDir, utils_namespaceObject.SERVER_DIR, `${meta}.server.js`);
+    return external_fs_default().existsSync(tsFilepath) || external_fs_default().existsSync(jsfilepath);
+}
+const serverBuild = ()=>({
+        name: '@modern-js/server-build',
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const { appDirectory, distDirectory, metaName } = api.getAppContext();
+                if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) return;
+                const modernConfig = api.getNormalizedConfig();
+                const distDir = external_path_default().resolve(distDirectory);
+                const serverDir = external_path_default().resolve(appDirectory, utils_namespaceObject.SERVER_DIR);
+                const sharedDir = external_path_default().resolve(appDirectory, utils_namespaceObject.SHARED_DIR);
+                const tsconfigPath = external_path_default().resolve(appDirectory, TS_CONFIG_FILENAME);
+                const sourceDirs = [];
+                if (external_fs_default().existsSync(serverDir)) {
+                    sourceDirs.push(serverDir);
+                    if (external_fs_default().existsSync(sharedDir)) sourceDirs.push(sharedDir);
+                }
+                const { server } = modernConfig;
+                const { alias } = modernConfig.source;
+                if (sourceDirs.length > 0) await (0, server_utils_namespaceObject.compile)(appDirectory, {
+                    server,
+                    alias
+                }, {
+                    sourceDirs,
+                    distDir,
+                    tsconfigPath
+                });
+            });
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/serverRuntime.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>__rspack_default_export
+});
+const __rspack_default_export = ()=>({
+        name: '@modern-js/plugin-server-runtime',
+        setup (api) {
+            api.config(()=>({
+                    output: {
+                        externals: [
+                            {
+                                '@modern-js/server-runtime': '@modern-js/server-runtime'
+                            }
+                        ]
+                    }
+                }));
+        }
+    });
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/run/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createRunOptions: ()=>createRunOptions,
+    run: ()=>run
+});
+const cli_namespaceObject = require("@modern-js/plugin/cli");
+const run_namespaceObject = require("@modern-js/plugin/run");
+const utils_namespaceObject = require("@modern-js/utils");
+const hooks_js_namespaceObject = require("../compat/hooks.js");
+const getConfigFile_js_namespaceObject = require("../utils/getConfigFile.js");
+const loadPlugins_js_namespaceObject = require("../utils/loadPlugins.js");
+async function createRunOptions({ cwd, initialLog, metaName = 'modern-js', version, internalPlugins, configFile }) {
+    const nodeVersion = process.versions.node;
+    const versionArr = nodeVersion.split('.').map(Number);
+    if (versionArr[0] <= 16) console.warn(`
+  ${utils_namespaceObject.chalk.bgRed.white.bold(' ⚠️ CRITICAL NODE.JS VERSION ALERT ⚠️ ')}
+
+  ${utils_namespaceObject.chalk.red.bold('Node.js 16 End-of-Life Notice:')}
+  ${utils_namespaceObject.chalk.red('- Security updates and support have ended for Node.js 16')}
+
+  ${utils_namespaceObject.chalk.yellow('▸ Detected Runtime:')}  ${utils_namespaceObject.chalk.yellow.bold(`Node.js v${nodeVersion}`)}
+  ${utils_namespaceObject.chalk.green('▸ Required Minimum:')} ${utils_namespaceObject.chalk.green.bold('Node.js LTS (v18.x or higher)')}
+  ${utils_namespaceObject.chalk.green('▸ Recommended:')} ${utils_namespaceObject.chalk.green.bold('Node.js LTS (v22.x or higher)')}
+
+  ${utils_namespaceObject.chalk.cyan('Immediate Action Required:')}
+    ${utils_namespaceObject.chalk.gray('├──')} ${utils_namespaceObject.chalk.yellow('Recommended Upgrade')}
+       ${utils_namespaceObject.chalk.bold('nvm install 22 --lts && nvm use 22')}
+    ${utils_namespaceObject.chalk.gray('├──')} ${utils_namespaceObject.chalk.yellow('Manual Installation')}
+       ${utils_namespaceObject.chalk.underline('https://nodejs.org/download/release/lts-hydrogen/')}
+     ${utils_namespaceObject.chalk.gray('└──')} ${utils_namespaceObject.chalk.yellow('Environment Verification')}
+       ${utils_namespaceObject.chalk.bold('node -v && npm -v')}
+
+  ${utils_namespaceObject.chalk.hex('#AAAAAA').italic('[Security Advisory] Node.js 16 is no longer supported. Upgrade immediately for security and compatibility.')}
+      `);
+    const command = process.argv[2];
+    const cliParams = (0, utils_namespaceObject.minimist)(process.argv.slice(2));
+    const SUPPORT_CONFIG_PARAM_COMMANDS = [
+        'dev',
+        'build',
+        'deploy',
+        'start',
+        'serve',
+        'inspect',
+        'info',
+        'upgrade'
+    ];
+    let customConfigFile;
+    if (SUPPORT_CONFIG_PARAM_COMMANDS.includes(command)) customConfigFile = cliParams.config || cliParams.c;
+    if ('new' === command) customConfigFile = cliParams['config-file'];
+    const appDirectory = await (0, cli_namespaceObject.initAppDir)(cwd);
+    const finalConfigFile = customConfigFile || (0, getConfigFile_js_namespaceObject.getConfigFile)(configFile);
+    const plugins = await (0, loadPlugins_js_namespaceObject.loadInternalPlugins)(appDirectory, internalPlugins);
+    return {
+        cwd,
+        initialLog: initialLog || `Modern.js Framework v${version}`,
+        configFile: finalConfigFile,
+        metaName,
+        internalPlugins: plugins,
+        handleSetupResult: hooks_js_namespaceObject.handleSetupResult
+    };
+}
+async function run(options) {
+    const runOptions = await createRunOptions(options);
+    await (0, run_namespaceObject.run)(runOptions);
+}
+exports.createRunOptions = __webpack_exports__.createRunOptions;
+exports.run = __webpack_exports__.run;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRunOptions",
+    "run"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types/config/deploy.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types/config/dev.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types/config/experiments.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});