@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

package/dist/esm/plugins/serverBuild.mjs

@@ -0,0 +1,45 @@
+import { compile } from "@modern-js/server-utils";
+import { SERVER_DIR, SHARED_DIR, getMeta, resolveServerTsconfig } from "@modern-js/utils";
+import fs from "fs";
+import path from "path";
+function checkHasCache(appDir) {
+    const tsFilepath = path.resolve(appDir, SERVER_DIR, 'cache.ts');
+    const jsfilepath = path.resolve(appDir, SERVER_DIR, 'cache.js');
+    return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+function checkHasConfig(appDir, metaName = 'modern-js') {
+    const meta = getMeta(metaName);
+    const tsFilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.ts`);
+    const jsfilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.js`);
+    return fs.existsSync(tsFilepath) || fs.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 = path.resolve(distDirectory);
+                const serverDir = path.resolve(appDirectory, SERVER_DIR);
+                const sharedDir = path.resolve(appDirectory, SHARED_DIR);
+                const tsconfigPath = resolveServerTsconfig(appDirectory, modernConfig?.server?.tsconfigPath);
+                const sourceDirs = [];
+                if (fs.existsSync(serverDir)) {
+                    sourceDirs.push(serverDir);
+                    if (fs.existsSync(sharedDir)) sourceDirs.push(sharedDir);
+                }
+                const { server } = modernConfig;
+                const { alias } = modernConfig.source;
+                if (sourceDirs.length > 0) await compile(appDirectory, {
+                    server,
+                    alias
+                }, {
+                    sourceDirs,
+                    distDir,
+                    tsconfigPath
+                });
+            });
+        }
+    });
+export default serverBuild;

package/dist/esm/plugins/serverRuntime.mjs

@@ -0,0 +1,15 @@
+const serverRuntime = ()=>({
+        name: '@modern-js/plugin-server-runtime',
+        setup (api) {
+            api.config(()=>({
+                    output: {
+                        externals: [
+                            {
+                                '@modern-js/server-runtime': '@modern-js/server-runtime'
+                            }
+                        ]
+                    }
+                }));
+        }
+    });
+export default serverRuntime;

package/dist/esm/presetUltramodern.mjs

@@ -0,0 +1,4 @@
+import { createAppBaselineConfig, withAppBaseline } from "./baseline.mjs";
+const createPresetUltramodernConfig = (options = {})=>createAppBaselineConfig(options);
+const presetUltramodern = (config, options = {})=>withAppBaseline(config, options);
+export { createPresetUltramodernConfig, presetUltramodern };

package/dist/esm/rsbuild.mjs

@@ -0,0 +1,47 @@
+import { parseRspackConfig } from "@modern-js/builder";
+import { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./builder/shared/builderPlugins/index.mjs";
+import { DEFAULT_CONFIG_FILE } from "./constants.mjs";
+import { getConfigFile } from "./utils/getConfigFile.mjs";
+import { __webpack_require__ } from "./rslib-runtime.mjs";
+import * as __rspack_external__modern_js_plugin_cli_caa09fa2 from "@modern-js/plugin/cli";
+__webpack_require__.add({
+    "@modern-js/plugin/cli?f956" (module) {
+        module.exports = __rspack_external__modern_js_plugin_cli_caa09fa2;
+    }
+});
+const MODERN_META_NAME = 'modern-js';
+const { createConfigOptions: createConfigOptions } = __webpack_require__("@modern-js/plugin/cli?f956");
+async function resolveModernRsbuildConfig(options) {
+    const { cwd = process.cwd(), metaName = MODERN_META_NAME } = options;
+    const configFile = options.configPath || getConfigFile(void 0, cwd);
+    if (!configFile) throw new Error(`Cannot find config file in ${cwd}. Please make sure you have a ${DEFAULT_CONFIG_FILE} file in your project.`);
+    const { config: modernConfig, getAppContext } = await createConfigOptions({
+        command: options.command,
+        cwd,
+        configFile,
+        metaName,
+        modifyModernConfig: options.modifyModernConfig
+    });
+    const nonStandardConfig = {
+        ...modernConfig,
+        plugins: modernConfig.builderPlugins
+    };
+    const appContext = getAppContext();
+    const { rsbuildConfig, rsbuildPlugins } = await parseRspackConfig(nonStandardConfig, {
+        cwd
+    });
+    const adapterParams = {
+        appContext,
+        normalizedConfig: modernConfig
+    };
+    rsbuildConfig.plugins = [
+        ...rsbuildPlugins,
+        ...rsbuildConfig.plugins || [],
+        builderPluginAdapterBasic(adapterParams),
+        builderPluginAdapterHooks(adapterParams)
+    ];
+    return {
+        rsbuildConfig
+    };
+}
+export { resolveModernRsbuildConfig };

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,18 @@
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };

package/dist/esm/run/index.mjs

@@ -0,0 +1,61 @@
+import { initAppDir } from "@modern-js/plugin/cli";
+import { run } from "@modern-js/plugin/run";
+import { chalk, minimist } from "@modern-js/utils";
+import { handleSetupResult } from "../compat/hooks.mjs";
+import { getConfigFile } from "../utils/getConfigFile.mjs";
+import { loadInternalPlugins } from "../utils/loadPlugins.mjs";
+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(`
+  ${chalk.bgRed.white.bold(' ⚠️ CRITICAL NODE.JS VERSION ALERT ⚠️ ')}
+
+  ${chalk.red.bold('Node.js 16 End-of-Life Notice:')}
+  ${chalk.red('- Security updates and support have ended for Node.js 16')}
+
+  ${chalk.yellow('▸ Detected Runtime:')}  ${chalk.yellow.bold(`Node.js v${nodeVersion}`)}
+  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js LTS (v18.x or higher)')}
+  ${chalk.green('▸ Recommended:')} ${chalk.green.bold('Node.js LTS (v22.x or higher)')}
+
+  ${chalk.cyan('Immediate Action Required:')}
+    ${chalk.gray('├──')} ${chalk.yellow('Recommended Upgrade')}
+       ${chalk.bold('nvm install 22 --lts && nvm use 22')}
+    ${chalk.gray('├──')} ${chalk.yellow('Manual Installation')}
+       ${chalk.underline('https://nodejs.org/download/release/lts-hydrogen/')}
+     ${chalk.gray('└──')} ${chalk.yellow('Environment Verification')}
+       ${chalk.bold('node -v && npm -v')}
+
+  ${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 = 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 initAppDir(cwd);
+    const finalConfigFile = customConfigFile || getConfigFile(configFile);
+    const plugins = await loadInternalPlugins(appDirectory, internalPlugins);
+    return {
+        cwd,
+        initialLog: initialLog || `Modern.js Framework v${version}`,
+        configFile: finalConfigFile,
+        metaName,
+        internalPlugins: plugins,
+        handleSetupResult: handleSetupResult
+    };
+}
+async function run_run(options) {
+    const runOptions = await createRunOptions(options);
+    await run(runOptions);
+}
+export { createRunOptions, run_run as run };

package/dist/esm/types/config/index.mjs

@@ -0,0 +1 @@
+export * from "./output.mjs";

package/dist/esm/types/index.mjs

@@ -0,0 +1 @@
+export * from "./config/index.mjs";

package/dist/esm/ultramodern/designSystem.mjs

@@ -0,0 +1,73 @@
+const DESIGN_SYSTEM_MODES = [
+    'off',
+    'tokens',
+    'components',
+    'strict'
+];
+const DESIGN_SYSTEM_OVERRIDE_LAYERS = [
+    'brand',
+    'vertical',
+    'application'
+];
+const VALID_MODES = new Set(DESIGN_SYSTEM_MODES);
+const VALID_OVERRIDE_LAYERS = new Set(DESIGN_SYSTEM_OVERRIDE_LAYERS);
+const createValidationResult = (issues)=>({
+        valid: 0 === issues.length,
+        issues
+    });
+const addIssue = (issues, path, message)=>{
+    issues.push({
+        path,
+        message
+    });
+};
+const createDesignSystemTokenPackMap = (tokenPacks)=>new Map(tokenPacks.map((tokenPack)=>[
+            tokenPack.id,
+            tokenPack
+        ]));
+const validateDesignSystemConsumerCompatibility = (vertical, tokenPack, path = 'vertical')=>{
+    const issues = [];
+    const consumers = vertical.consumers ?? [];
+    for (const [consumerIndex, consumer] of consumers.entries()){
+        const consumerPath = `${path}.consumers[${consumerIndex}]`;
+        if (consumer.unsupportedModes?.includes(vertical.mode)) addIssue(issues, `${consumerPath}.unsupportedModes`, `consumer "${consumer.id}" does not support "${vertical.mode}" mode`);
+        if (!tokenPack) continue;
+        const expectedVersion = consumer.tokenPackVersions?.[tokenPack.id];
+        if (expectedVersion && expectedVersion !== tokenPack.version) addIssue(issues, `${consumerPath}.tokenPackVersions.${tokenPack.id}`, `consumer "${consumer.id}" requires "${tokenPack.id}" version "${expectedVersion}" but received "${tokenPack.version}"`);
+        for (const tokenName of consumer.requiredTokens ?? [])if (!(tokenName in tokenPack.tokens)) addIssue(issues, `${consumerPath}.requiredTokens`, `consumer "${consumer.id}" requires missing token "${tokenName}" from "${tokenPack.id}"`);
+    }
+    return createValidationResult(issues);
+};
+const validateDesignSystemContract = (contract)=>{
+    const issues = [];
+    const tokenPackMap = createDesignSystemTokenPackMap(contract.tokenPacks);
+    for (const [tokenPackIndex, tokenPack] of contract.tokenPacks.entries()){
+        const tokenPackPath = `tokenPacks[${tokenPackIndex}]`;
+        if (tokenPackMap.get(tokenPack.id) !== tokenPack) addIssue(issues, `${tokenPackPath}.id`, `duplicate token pack id "${tokenPack.id}"`);
+        if (0 === Object.keys(tokenPack.tokens).length) addIssue(issues, `${tokenPackPath}.tokens`, `token pack "${tokenPack.id}" must define at least one token`);
+    }
+    for (const [verticalName, vertical] of Object.entries(contract.verticals)){
+        const verticalPath = `verticals.${verticalName}`;
+        const tokenPack = vertical.tokenPack ? tokenPackMap.get(vertical.tokenPack) : void 0;
+        if (!VALID_MODES.has(vertical.mode)) addIssue(issues, `${verticalPath}.mode`, `unsupported design system mode "${vertical.mode}"`);
+        if ('off' !== vertical.mode && !vertical.tokenPack) addIssue(issues, `${verticalPath}.tokenPack`, `vertical "${verticalName}" must select a token pack when mode is "${vertical.mode}"`);
+        if (vertical.tokenPack && !tokenPack) addIssue(issues, `${verticalPath}.tokenPack`, `unknown token pack "${vertical.tokenPack}"`);
+        for (const [overrideIndex, override] of (vertical.overrides ?? []).entries())if (!VALID_OVERRIDE_LAYERS.has(override.layer)) addIssue(issues, `${verticalPath}.overrides[${overrideIndex}].layer`, `override layer "${override.layer}" is not approved`);
+        if (vertical.pin) {
+            const pinnedTokenPack = tokenPackMap.get(vertical.pin.tokenPack);
+            const rollbackTokenPack = tokenPackMap.get(vertical.pin.rollback.tokenPack);
+            if (pinnedTokenPack) {
+                if (pinnedTokenPack.version !== vertical.pin.version) addIssue(issues, `${verticalPath}.pin.version`, `pinned version "${vertical.pin.version}" does not match token pack "${vertical.pin.tokenPack}" version "${pinnedTokenPack.version}"`);
+            } else addIssue(issues, `${verticalPath}.pin.tokenPack`, `unknown pinned token pack "${vertical.pin.tokenPack}"`);
+            if (vertical.tokenPack && vertical.pin.tokenPack !== vertical.tokenPack) addIssue(issues, `${verticalPath}.pin.tokenPack`, `pinned token pack "${vertical.pin.tokenPack}" must match selected token pack "${vertical.tokenPack}"`);
+            if (rollbackTokenPack) {
+                if (rollbackTokenPack.version !== vertical.pin.rollback.version) addIssue(issues, `${verticalPath}.pin.rollback.version`, `rollback version "${vertical.pin.rollback.version}" does not match token pack "${vertical.pin.rollback.tokenPack}" version "${rollbackTokenPack.version}"`);
+            } else addIssue(issues, `${verticalPath}.pin.rollback.tokenPack`, `unknown rollback token pack "${vertical.pin.rollback.tokenPack}"`);
+            if (!vertical.pin.rollback.reason) addIssue(issues, `${verticalPath}.pin.rollback.reason`, 'rollback metadata must include a reason');
+        }
+        const compatibility = validateDesignSystemConsumerCompatibility(vertical, tokenPack, verticalPath);
+        issues.push(...compatibility.issues);
+    }
+    return createValidationResult(issues);
+};
+export { DESIGN_SYSTEM_MODES, DESIGN_SYSTEM_OVERRIDE_LAYERS, createDesignSystemTokenPackMap, validateDesignSystemConsumerCompatibility, validateDesignSystemContract };

package/dist/esm/utils/config.mjs

@@ -0,0 +1,11 @@
+import { OUTPUT_CONFIG_FILE, ensureAbsolutePath, fs } from "@modern-js/utils";
+import { stringify } from "flatted";
+import * as __rspack_external_path from "path";
+const emitResolvedConfig = async (appDirectory, resolvedConfig)=>{
+    const outputPath = ensureAbsolutePath(appDirectory, __rspack_external_path.join(resolvedConfig.output.distPath?.root || './dist', OUTPUT_CONFIG_FILE));
+    const output = stringify(resolvedConfig);
+    await fs.writeFile(outputPath, output, {
+        encoding: 'utf-8'
+    });
+};
+export { emitResolvedConfig };

package/dist/esm/utils/createServer.mjs

@@ -0,0 +1,12 @@
+let server = null;
+const getServer = ()=>server;
+const setServer = (newServer)=>{
+    server = newServer;
+};
+const closeServer = async ()=>{
+    if (server) {
+        server.close();
+        server = null;
+    }
+};
+export { closeServer, getServer, setServer };

package/dist/esm/utils/env.mjs

@@ -0,0 +1,12 @@
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+function getAutoInjectEnv(appContext) {
+    const { metaName } = appContext;
+    const prefix = `${cutNameByHyphen(metaName)}_`.toUpperCase();
+    const envReg = new RegExp(`^${prefix}`);
+    return Object.keys(process.env).reduce((prev, key)=>{
+        const value = process.env[key];
+        if (envReg.test(key) && void 0 !== value) prev[`process.env.${key}`] = value;
+        return prev;
+    }, {});
+}
+export { getAutoInjectEnv };

package/dist/esm/utils/generateWatchFiles.mjs

@@ -0,0 +1,10 @@
+import path from "path";
+async function generateWatchFiles(appContext, configDir) {
+    const { appDirectory, configFile } = appContext;
+    const configPath = path.join(appDirectory, configDir || '');
+    return [
+        `${configPath}/html`,
+        configFile || './config'
+    ];
+}
+export { generateWatchFiles };

package/dist/esm/utils/getConfigFile.mjs

@@ -0,0 +1,5 @@
+import { CONFIG_FILE_EXTENSIONS, findExists } from "@modern-js/utils";
+import path from "path";
+import { DEFAULT_CONFIG_FILE } from "../constants.mjs";
+const getConfigFile = (configFile, cwd = process.cwd())=>findExists(CONFIG_FILE_EXTENSIONS.map((extension)=>path.resolve(cwd, `${configFile || DEFAULT_CONFIG_FILE}${extension}`)));
+export { getConfigFile };

package/dist/esm/utils/getSelectedEntries.mjs

@@ -0,0 +1,26 @@
+import { chalk, inquirer } from "@modern-js/utils";
+import { i18n, localeKeys } from "../locale/index.mjs";
+const getSelectedEntries = async (entry, entrypoints)=>{
+    const entryNames = entrypoints.map((e)=>e.entryName);
+    if (!entry) return entryNames;
+    if ('boolean' == typeof entry) {
+        const { selected } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selected',
+                choices: entryNames,
+                message: i18n.t(localeKeys.command.dev.selectEntry),
+                validate (answer) {
+                    if (answer.length < 1) return i18n.t(localeKeys.command.dev.requireEntry);
+                    return true;
+                }
+            }
+        ]);
+        return selected;
+    }
+    entry.forEach((name)=>{
+        if (!entryNames.includes(name)) throw new Error(`Can not found entry ${chalk.yellow(name)}, the entry should be one of ${chalk.yellow(entryNames.join(', '))}`);
+    });
+    return entry;
+};
+export { getSelectedEntries };

package/dist/esm/utils/initAppContext.mjs

@@ -0,0 +1,27 @@
+import { address, fs } from "@modern-js/utils";
+import path from "path";
+const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, tempDir })=>{
+    const { apiDir = 'api', sharedDir = 'shared', bffRuntimeFramework = 'hono' } = options || {};
+    const pkgPath = path.resolve(appDirectory, './package.json');
+    const moduleType = fs.existsSync(pkgPath) ? fs.readJSONSync(pkgPath).type || 'commonjs' : 'commonjs';
+    return {
+        runtimeConfigFile,
+        ip: address.ip(),
+        port: 0,
+        moduleType,
+        apiDirectory: path.resolve(appDirectory, apiDir),
+        lambdaDirectory: path.resolve(appDirectory, apiDir, 'lambda'),
+        sharedDirectory: path.resolve(appDirectory, sharedDir),
+        serverPlugins: [],
+        internalDirectory: path.resolve(appDirectory, tempDir || `./node_modules/.${metaName}`),
+        htmlTemplates: {},
+        serverRoutes: [],
+        entrypoints: [],
+        checkedEntries: [],
+        apiOnly: false,
+        internalDirAlias: `@_${metaName.replace(/-/g, '_')}_internal`,
+        internalSrcAlias: `@_${metaName.replace(/-/g, '_')}_src`,
+        bffRuntimeFramework
+    };
+};
+export { initAppContext };

package/dist/esm/utils/loadPlugins.mjs

@@ -0,0 +1,45 @@
+import { loadServerPlugins } from "@modern-js/server-core/node";
+import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
+const debug = createDebugger('load-plugins');
+async function getServerPlugins(api, metaName = 'modern-js') {
+    const hooks = api.getHooks();
+    const { plugins } = await hooks._internalServerPlugins.call({
+        plugins: []
+    });
+    const filtedPlugins = plugins.filter((plugin)=>plugin.name.includes(metaName));
+    api.updateAppContext({
+        serverPlugins: filtedPlugins
+    });
+    return filtedPlugins;
+}
+async function loadPlugins_loadServerPlugins(api, appDirectory, metaName) {
+    const plugins = await getServerPlugins(api, metaName);
+    const instances = await loadServerPlugins(plugins, appDirectory);
+    return instances;
+}
+const resolveCliPlugin = async (p, appDirectory)=>{
+    const pkg = 'string' == typeof p ? p : p[0];
+    const pluginOptions = 'string' == typeof p ? void 0 : p[1];
+    const path = tryResolve(pkg, appDirectory);
+    let module;
+    try {
+        module = await compatibleRequire(path);
+    } catch (e) {
+        ({ default: module } = await dynamicImport(path));
+    }
+    if ('function' == typeof module) {
+        const result = module(pluginOptions);
+        return result;
+    }
+    return module;
+};
+const loadInternalPlugins = async (appDirectory, internalPlugins)=>{
+    const plugins = getInternalPlugins(appDirectory, internalPlugins);
+    const loadedPlugins = await Promise.all(plugins.map((plugin)=>{
+        const loadedPlugin = resolveCliPlugin(plugin, appDirectory);
+        debug("resolve plugin %s: %s", plugin, loadedPlugin);
+        return loadedPlugin;
+    }));
+    return loadedPlugins;
+};
+export { getServerPlugins, loadInternalPlugins, loadPlugins_loadServerPlugins as loadServerPlugins };

package/dist/esm/utils/printInstructions.mjs

@@ -0,0 +1,9 @@
+import { logger, prettyInstructions } from "@modern-js/utils";
+const printInstructions = async (hooks, appContext, config)=>{
+    const message = prettyInstructions(appContext, config);
+    const { instructions } = await hooks.onBeforePrintInstructions.call({
+        instructions: message
+    });
+    logger.log(instructions);
+};
+export { printInstructions };

package/dist/esm/utils/register.mjs

@@ -0,0 +1,81 @@
+import node_path from "node:path";
+import { fs, getAliasConfig, mergeAlias, resolveServerTsconfig } from "@modern-js/utils";
+const normalizePathValue = ({ key, value, absoluteBaseUrl })=>{
+    let normalizedValue = value;
+    if (key.startsWith('@') && normalizedValue.startsWith('@')) try {
+        normalizedValue = require.resolve(normalizedValue, {
+            paths: [
+                process.cwd(),
+                ...module.paths
+            ]
+        });
+    } catch  {}
+    return node_path.isAbsolute(normalizedValue) ? node_path.relative(absoluteBaseUrl, normalizedValue) : normalizedValue;
+};
+const normalizePathValues = ({ key, value, absoluteBaseUrl })=>{
+    const values = Array.isArray(value) ? value : [
+        value
+    ];
+    return values.map((item)=>normalizePathValue({
+            key,
+            value: item,
+            absoluteBaseUrl
+        }));
+};
+const addResolvedAlias = (paths, key, values)=>{
+    if (!key || paths[key]) return;
+    paths[key] = values;
+};
+const createRuntimePaths = ({ alias, paths, absoluteBaseUrl })=>{
+    const mergedAlias = mergeAlias(alias);
+    const normalizedPaths = Object.keys(paths).reduce((result, key)=>{
+        addResolvedAlias(result, key.endsWith('$') ? key.slice(0, -1) : key, normalizePathValues({
+            key,
+            value: paths[key],
+            absoluteBaseUrl
+        }));
+        return result;
+    }, {});
+    Object.keys(mergedAlias).forEach((key)=>{
+        if (key.includes('*') || key.endsWith('$')) return;
+        addResolvedAlias(normalizedPaths, `${key}/*`, normalizePathValues({
+            key,
+            value: mergedAlias[key],
+            absoluteBaseUrl
+        }).map((value)=>`${value}/*`));
+    });
+    return normalizedPaths;
+};
+const resolveTsRuntimeRegisterMode = ()=>{
+    const hasNativeTypeScriptSupport = process.features?.typescript;
+    const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
+    const supportsNativeTypeScript = void 0 === hasNativeTypeScriptSupport ? nodeMajorVersion >= 22 : false !== hasNativeTypeScriptSupport;
+    if (supportsNativeTypeScript) return 'node-loader';
+    return 'unsupported';
+};
+const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
+    const tsconfigPath = resolveServerTsconfig(appDir, options.tsconfigPath);
+    const isTsProject = await fs.pathExists(tsconfigPath);
+    if (!isTsProject) return;
+    const registerMode = resolveTsRuntimeRegisterMode();
+    const aliasConfig = getAliasConfig(alias, {
+        appDirectory: appDir,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
+    const runtimePaths = createRuntimePaths({
+        alias,
+        paths,
+        absoluteBaseUrl
+    });
+    if ('unsupported' === registerMode) return;
+    if ('node-loader' === registerMode) {
+        const { registerPathsLoader } = await import("../esm/register-esm.mjs");
+        await registerPathsLoader({
+            appDir,
+            baseUrl: absoluteBaseUrl || './',
+            paths: runtimePaths
+        });
+    }
+};
+export { resolveTsRuntimeRegisterMode, setupTsRuntime };

package/dist/esm/utils/restart.mjs

@@ -0,0 +1,18 @@
+import { cli } from "@modern-js/plugin/cli";
+import { chalk, clearConsole, getFullArgv, logger } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
+async function restart(hooks, filename) {
+    clearConsole();
+    logger.info(`Restart because ${chalk.yellow(filename)} is changed...\n`);
+    let hasGetError = false;
+    await hooks.onBeforeRestart.call();
+    try {
+        await cli.init(cli.getPrevInitOptions());
+    } catch (err) {
+        console.error(err);
+        hasGetError = true;
+    } finally{
+        if (!hasGetError) program.parse(getFullArgv());
+    }
+}
+export { restart };

package/dist/esm/utils/routes.mjs

@@ -0,0 +1,15 @@
+import { MAIN_ENTRY_NAME, ROUTE_SPEC_FILE, fs } from "@modern-js/utils";
+import path from "path";
+const generateRoutes = async (appContext)=>{
+    const { serverRoutes, distDirectory } = appContext;
+    const output = JSON.stringify({
+        routes: serverRoutes
+    }, null, 2);
+    await fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output);
+};
+const getPathWithoutExt = (filename)=>{
+    const extname = path.extname(filename);
+    return filename.slice(0, -extname.length);
+};
+const isMainEntry = (entryName, mainEntryName)=>entryName === (mainEntryName || MAIN_ENTRY_NAME);
+export { generateRoutes, getPathWithoutExt, isMainEntry };

package/dist/esm-node/baseline.mjs

@@ -0,0 +1,47 @@
+import "node:module";
+import { mergeConfig } from "@modern-js/plugin/cli";
+const createAppBaselineConfig = (options = {})=>{
+    const { appId = 'app', enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters = true, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs', victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus', telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
+    const server = {};
+    if (enableTelemetry) {
+        server.telemetry = {
+            enabled: true,
+            failLoudStartup: telemetryFailLoudStartup
+        };
+        if (enableTelemetryExporters) server.telemetry.exporters = {
+            otlp: {
+                enabled: true,
+                endpoint: otlpEndpoint
+            },
+            victoriaMetrics: {
+                enabled: true,
+                endpoint: victoriaMetricsEndpoint
+            }
+        };
+    }
+    if (enableModuleFederationSSR) server.ssr = {
+        mode: 'stream',
+        moduleFederationAppSSR: true
+    };
+    const baselineConfig = {
+        output: {
+            precompress: true
+        },
+        performance: {
+            rsdoctor: {
+                enabled: 'production' === process.env.NODE_ENV,
+                disableClientServer: true
+            }
+        },
+        server
+    };
+    if (enableBffRequestId) baselineConfig.bff = {
+        requestId: appId
+    };
+    return baselineConfig;
+};
+const withAppBaseline = (config, options = {})=>mergeConfig([
+        createAppBaselineConfig(options),
+        config
+    ]);
+export { createAppBaselineConfig, withAppBaseline };