@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.10 → 3.5.0-ultramodern.101

package/dist/esm-node/builder/shared/bundlerPlugins/RouterPlugin.mjs

@@ -5,6 +5,13 @@ import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 import { createHash } from "crypto";
 const PLUGIN_NAME = 'ModernjsRoutePlugin';
 const generateContentHash = (content)=>createHash('md5').update(content).digest('hex').slice(0, 8);
+const isAutomaticPublicPath = (publicPath)=>'auto' === publicPath || 'auto/' === publicPath;
+const normalizeAutomaticHtmlAsset = (asset)=>asset.startsWith('auto/') ? `/${asset.slice(5)}` : asset;
+const normalizeRouterAssetPublicPath = (publicPath)=>{
+    if (!publicPath) return '';
+    if (isAutomaticPublicPath(publicPath)) return '/';
+    return publicPath.endsWith('/') ? publicPath : `${publicPath}/`;
+};
 class RouterPlugin {
     isTargetNodeOrWebWorker(target) {
         if ('node' === target || Array.isArray(target) && target.includes('node')) return true;
@@ -30,15 +37,21 @@ class RouterPlugin {
         const { rspack } = compiler;
         const { Compilation, sources } = rspack;
         const { RawSource } = sources;
-        const normalizePath = (path)=>{
-            if (!path.endsWith('/')) return `${path}/`;
-            return path;
-        };
         const chunksToHtmlName = new Map();
         const ROUTE_MANIFEST_HOLDER = "route-manifest";
         const placeholder = `<!--<?- ${ROUTE_MANIFEST_HOLDER} ?>-->`;
         compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
-            this.HtmlBundlerPlugin.getCompilationHooks(compilation).beforeEmit.tapAsync('RouterManifestPlugin', (data, callback)=>{
+            const htmlPluginHooks = this.HtmlBundlerPlugin.getCompilationHooks(compilation);
+            htmlPluginHooks.beforeAssetTagGeneration.tapAsync('RouterManifestPlugin', (data, callback)=>{
+                if (isAutomaticPublicPath(compiler.options.output.publicPath)) {
+                    data.assets.publicPath = '/';
+                    data.assets.js = data.assets.js.map(normalizeAutomaticHtmlAsset);
+                    data.assets.css = data.assets.css.map(normalizeAutomaticHtmlAsset);
+                    if (data.assets.favicon) data.assets.favicon = normalizeAutomaticHtmlAsset(data.assets.favicon);
+                }
+                callback(null, data);
+            });
+            htmlPluginHooks.beforeEmit.tapAsync('RouterManifestPlugin', (data, callback)=>{
                 const { outputName } = data;
                 const { chunks } = data.plugin.options;
                 chunksToHtmlName.set(chunks, outputName);
@@ -58,6 +71,7 @@ class RouterPlugin {
                     ids: true
                 });
                 const { publicPath, chunks = [], namedChunkGroups } = stats;
+                const assetPublicPath = normalizeRouterAssetPublicPath(publicPath);
                 const routeAssets = {};
                 if (!namedChunkGroups) return;
                 const prevManifestAsset = compilation.getAsset(ROUTE_MANIFEST_FILE);
@@ -79,7 +93,7 @@ class RouterPlugin {
                         const child = stack.pop();
                         if (visited.has(child)) continue;
                         visited.add(child);
-                        for (const chunk of child.chunks)for (const file of chunk.files)if (/\.css$/.test(file)) cssFiles.add(publicPath ? normalizePath(publicPath) + file : file);
+                        for (const chunk of child.chunks)for (const file of chunk.files)if (/\.css$/.test(file)) cssFiles.add(assetPublicPath + file);
                         for (const c of child.childrenIterable)stack.push(c);
                     }
                     return Array.from(cssFiles);
@@ -89,7 +103,7 @@ class RouterPlugin {
                     if (name.startsWith('async-')) asyncEntryNames.push(name);
                     const assets = chunkGroup.assets.map((asset)=>{
                         const filename = asset.name;
-                        return publicPath ? normalizePath(publicPath) + filename : filename;
+                        return assetPublicPath + filename;
                     });
                     const directCssAssets = assets.filter((asset)=>/\.css$/.test(asset));
                     const descendantCssAssets = collectDescendantCssAssets(name).filter((asset)=>!directCssAssets.includes(asset));
@@ -144,7 +158,7 @@ class RouterPlugin {
               window.${ROUTE_MANIFEST} = ${JSON.stringify(manifest, (k, v)=>{
                         if (('assets' === k || 'referenceCssAssets' === k) && Array.isArray(v)) {
                             if (!useRsc) return;
-                            return v.map((item)=>item.replace(publicPath, ''));
+                            return v.map((item)=>assetPublicPath ? item.replace(assetPublicPath, '') : item);
                         }
                         return v;
                     })};
@@ -161,7 +175,7 @@ class RouterPlugin {
                     if (oldHtml) if (enableInlineRouteManifests) compilation.updateAsset(htmlName, new RawSource(oldHtml.source().toString().replace(placeholder, `<script ${nonceAttr}>${injectedContent}</script>`)), void 0);
                     else {
                         const scriptPath = `${staticJsDir}/${ROUTE_MANIFEST_HOLDER}-${entryName}${disableFilenameHash ? '.js' : `.${generateContentHash(injectedContent)}.js`}`;
-                        const scriptUrl = `${publicPath}${scriptPath}`;
+                        const scriptUrl = `${assetPublicPath}${scriptPath}`;
                         const scriptLoadingAttr = 'defer' === scriptLoading ? scriptLoading : 'module' === scriptLoading ? 'type="module"' : '';
                         const script = `<script ${scriptLoadingAttr} ${nonceAttr} src="${scriptUrl}"></script>`;
                         compilation.updateAsset(htmlName, new RawSource(oldHtml.source().toString().replace(placeholder, script)), void 0);
@@ -184,4 +198,4 @@ class RouterPlugin {
         this.useRsc = useRsc;
     }
 }
-export { RouterPlugin };
+export { RouterPlugin, normalizeRouterAssetPublicPath };

package/dist/esm-node/builder/shared/bundlerPlugins/index.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+export * from "./CssExtractRuntimePlugin.mjs";
 export * from "./HtmlAsyncChunkPlugin.mjs";
 export * from "./HtmlBottomTemplate.mjs";
 export * from "./RouterPlugin.mjs";

package/dist/esm-node/builder/shared/lazyCompilation.mjs

@@ -21,7 +21,6 @@ function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
-const buildSSRLazyCompilationTest = buildRouteEagerLazyCompilationTest;
 function planRouteEagerLazyCompilation(current, info) {
     if (!current) return {
         apply: false
@@ -43,5 +42,4 @@ function planRouteEagerLazyCompilation(current, info) {
         }
     };
 }
-const planSSRLazyCompilation = planRouteEagerLazyCompilation;
-export { aggregateEagerRouteComponentFiles, buildRouteEagerLazyCompilationTest, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planRouteEagerLazyCompilation, planSSRLazyCompilation };
+export { aggregateEagerRouteComponentFiles, buildRouteEagerLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planRouteEagerLazyCompilation };

package/dist/esm-node/bundleDocs.mjs

@@ -0,0 +1,63 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+const DEFAULT_INDEX_FILE = 'llms.txt';
+const DEFAULT_EXCLUDED_DIRS = [
+    'zh'
+];
+function bundleDocs({ source, target, indexFile = DEFAULT_INDEX_FILE, excludedDirs = DEFAULT_EXCLUDED_DIRS }) {
+    if (!node_fs.existsSync(source)) {
+        console.warn(`[bundle-docs] docs build output not found: ${source}`);
+        console.warn('[bundle-docs] skipping the bundled docs — build the docs site first if you need them');
+        return 0;
+    }
+    node_fs.rmSync(target, {
+        recursive: true,
+        force: true
+    });
+    const isBundled = (rel)=>rel === indexFile || rel.endsWith('.md') && !excludedDirs.some((dir)=>rel.startsWith(`${dir}${node_path.sep}`));
+    let count = 0;
+    for (const entry of node_fs.readdirSync(source, {
+        recursive: true,
+        withFileTypes: true
+    })){
+        if (!entry.isFile()) continue;
+        const from = node_path.join(entry.parentPath ?? entry.path, entry.name);
+        const rel = node_path.relative(source, from);
+        if (!isBundled(rel)) continue;
+        const to = node_path.join(target, rel);
+        node_fs.mkdirSync(node_path.dirname(to), {
+            recursive: true
+        });
+        node_fs.copyFileSync(from, to);
+        count++;
+    }
+    if (0 === count) throw new Error(`[bundle-docs] no files copied from ${source}`);
+    return count;
+}
+function parseArgs(argv) {
+    const options = {};
+    for(let i = 0; i < argv.length; i += 2){
+        const key = argv[i]?.replace(/^--/, '');
+        const value = argv[i + 1];
+        if (key && value) options[key] = value;
+    }
+    return options;
+}
+function runBundleDocsCli(pkgRoot) {
+    const args = parseArgs(process.argv.slice(2));
+    const source = args.source ? node_path.resolve(process.cwd(), args.source) : node_path.resolve(pkgRoot, '../../document/doc_build');
+    const target = args.target ? node_path.resolve(process.cwd(), args.target) : node_path.resolve(pkgRoot, 'docs');
+    try {
+        const count = bundleDocs({
+            source,
+            target,
+            indexFile: args.index
+        });
+        if (count > 0) console.log(`[bundle-docs] bundled ${count} doc files into docs`);
+    } catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+export { bundleDocs, runBundleDocsCli };

package/dist/esm-node/commands/build.mjs

@@ -57,8 +57,9 @@ const build = async (api, options)=>{
     logger.info('Starting production build...');
     if (!appContext.builder) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
     await appContext.builder.onAfterBuild(async ()=>copyEnvFiles(appContext.appDirectory, appContext.distDirectory));
-    await appContext.builder.build({
+    const buildResult = await appContext.builder.build({
         watch: options?.watch
     });
+    if (!options?.watch) await buildResult?.close();
 };
 export { build };

package/dist/esm-node/commands/deploy.mjs

@@ -1,9 +1,11 @@
 import "node:module";
 import { getServerPlugins } from "../utils/loadPlugins.mjs";
-const deploy = async (api, options)=>{
+import { build } from "./build.mjs";
+const deploy = async (api, options = {})=>{
     const hooks = api.getHooks();
     const { metaName } = api.getAppContext();
-    await getServerPlugins(api, metaName);
+    if (options.skipBuild) await getServerPlugins(api, metaName);
+    else await build(api);
     await hooks.onBeforeDeploy.call(options);
     await hooks.deploy.call();
     await hooks.onAfterDeploy.call(options);

package/dist/esm-node/commands/index.mjs

@@ -20,10 +20,6 @@ const serverCommand = (program, api)=>{
 };
 const deployCommand = (program, api)=>{
     program.command('deploy').usage('[options]').option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-s --skip-build', i18n.t(localeKeys.command.shared.skipBuild)).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options)=>{
-        if (!options.skipBuild) {
-            const { build } = await import("./build.mjs");
-            await build(api);
-        }
         const { deploy } = await import("./deploy.mjs");
         await deploy(api, options);
         process.exit(0);
@@ -41,5 +37,4 @@ const infoCommand = (program, api)=>{
         await info(api, options);
     });
 };
-export { runtimeCommand } from "./runtime.mjs";
 export { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand };

package/dist/esm-node/config/build-environment.mjs

@@ -0,0 +1,225 @@
+import "node:module";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { accessSync, chmodSync, constants, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
+const EFFECT_TSGO_BIN = 'effect-tsgo';
+const EFFECT_TSGO_RESOLUTION_ERROR = 'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN.';
+const executableEffectTsgoCompilers = new Map();
+const BUILD_CONFIG_ENVIRONMENT_PLUGIN = 'ModernJsBuildConfigEnvironmentLeasePlugin';
+const ENVIRONMENT_LEASE_REGISTRY_KEY = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry/v1');
+const ENVIRONMENT_LEASE_REGISTRY_BRAND = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry-brand/v1');
+const LIFECYCLE_HOOK_NAMES = [
+    'run',
+    'watchRun',
+    'afterDone',
+    'failed',
+    'shutdown',
+    'watchClose'
+];
+function restoreEnvironment(name, value) {
+    if (void 0 === value) delete process.env[name];
+    else process.env[name] = value;
+}
+function createEnvironmentLeaseRegistry() {
+    const environmentLeases = new Map();
+    return Object.freeze({
+        acquire (name, value) {
+            let lease = environmentLeases.get(name);
+            if (lease) {
+                if (lease.value !== value) throw new Error(`Build config environment "${name}" already has an active lease for a different value.`);
+                if (process.env[name] !== lease.value) throw new Error(`Build config environment lease for "${name}" lost ownership before another lease was acquired.`);
+            } else {
+                lease = {
+                    originalValue: process.env[name],
+                    owners: new Set(),
+                    value
+                };
+                process.env[name] = value;
+                environmentLeases.set(name, lease);
+            }
+            const owner = Symbol(name);
+            lease.owners.add(owner);
+            let released = false;
+            return ()=>{
+                if (released) return;
+                if (environmentLeases.get(name) !== lease || !lease.owners.has(owner)) throw new Error(`Build config environment lease for "${name}" cannot be restored because its ownership record was lost.`);
+                released = true;
+                const lostOwnership = process.env[name] !== lease.value;
+                lease.owners.delete(owner);
+                if (0 === lease.owners.size) {
+                    environmentLeases.delete(name);
+                    restoreEnvironment(name, lease.originalValue);
+                } else if (lostOwnership) process.env[name] = lease.value;
+                if (lostOwnership) throw new Error(`Build config environment lease for "${name}" lost ownership before restoration.`);
+            };
+        },
+        brand: ENVIRONMENT_LEASE_REGISTRY_BRAND
+    });
+}
+function getEnvironmentLeaseRegistry() {
+    const descriptor = Object.getOwnPropertyDescriptor(process, ENVIRONMENT_LEASE_REGISTRY_KEY);
+    if (descriptor) {
+        const registry = descriptor.value;
+        if (descriptor.configurable || descriptor.enumerable || descriptor.writable || registry?.brand !== ENVIRONMENT_LEASE_REGISTRY_BRAND || 'function' != typeof registry.acquire) throw new Error('The process-global build config environment lease registry is occupied by an incompatible value.');
+        return registry;
+    }
+    const registry = createEnvironmentLeaseRegistry();
+    Object.defineProperty(process, ENVIRONMENT_LEASE_REGISTRY_KEY, {
+        configurable: false,
+        enumerable: false,
+        value: registry,
+        writable: false
+    });
+    return registry;
+}
+function acquireEnvironmentLease(name, value) {
+    return getEnvironmentLeaseRegistry().acquire(name, value);
+}
+function releaseAfterFailure(release, originalError) {
+    try {
+        release();
+    } catch (restorationError) {
+        throw new AggregateError([
+            originalError,
+            restorationError
+        ], 'Build config environment setup and restoration both failed.');
+    }
+    throw originalError;
+}
+class BuildConfigEnvironmentLeasePlugin {
+    apply(compiler) {
+        const hooks = compiler.hooks;
+        try {
+            const lifecycleHooks = {};
+            for (const hookName of LIFECYCLE_HOOK_NAMES){
+                const hook = hooks[hookName];
+                if (!hook || 'function' != typeof hook.tap) throw new Error(`Rspack does not expose the "${hookName}" lifecycle hook required to restore build config environment leases.`);
+                lifecycleHooks[hookName] = hook;
+            }
+            let mode = 'pending';
+            const modeTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MIN_SAFE_INTEGER
+            };
+            const releaseTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MAX_SAFE_INTEGER
+            };
+            const releaseAfterOneShot = ()=>{
+                if ('watch' !== mode && true !== compiler.watchMode) this.release();
+            };
+            lifecycleHooks.run.tap(modeTap, ()=>{
+                mode = 'run';
+            });
+            lifecycleHooks.watchRun.tap(modeTap, ()=>{
+                mode = 'watch';
+            });
+            lifecycleHooks.afterDone.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.failed.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.shutdown.tap(releaseTap, this.release);
+            lifecycleHooks.watchClose.tap(releaseTap, this.release);
+        } catch (error) {
+            releaseAfterFailure(this.release, error);
+        }
+    }
+    constructor(release){
+        this.release = release;
+    }
+}
+function resolveEffectTsgoCli(from) {
+    const projectRequire = createRequire(from);
+    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const bin = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.[EFFECT_TSGO_BIN];
+    if (!bin) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    return resolve(dirname(packageJsonPath), bin);
+}
+function resolveExecutableEffectTsgoCompiler(compilerPath) {
+    if ('win32' === process.platform) return compilerPath;
+    const sourcePath = realpathSync(compilerPath);
+    const source = lstatSync(sourcePath);
+    if (!source.isFile()) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    try {
+        accessSync(sourcePath, constants.X_OK);
+        return compilerPath;
+    } catch  {}
+    const cachedCompiler = executableEffectTsgoCompilers.get(sourcePath);
+    if (cachedCompiler) try {
+        accessSync(cachedCompiler, constants.X_OK);
+        return cachedCompiler;
+    } catch  {
+        executableEffectTsgoCompilers.delete(sourcePath);
+    }
+    const compilerBytes = readFileSync(sourcePath);
+    const compilerDigest = createHash('sha256').update(compilerBytes).digest('hex');
+    const compilerDirectory = join(tmpdir(), 'modern-js', 'effect-tsgo', compilerDigest);
+    mkdirSync(compilerDirectory, {
+        recursive: true,
+        mode: 448
+    });
+    const executableCompiler = join(compilerDirectory, basename(sourcePath));
+    try {
+        accessSync(executableCompiler, constants.X_OK);
+    } catch  {
+        const temporaryCompiler = join(compilerDirectory, `.${basename(sourcePath)}.${process.pid}.tmp`);
+        rmSync(temporaryCompiler, {
+            force: true
+        });
+        try {
+            writeFileSync(temporaryCompiler, compilerBytes, {
+                flag: 'wx',
+                mode: 448
+            });
+            chmodSync(temporaryCompiler, 448);
+            renameSync(temporaryCompiler, executableCompiler);
+        } finally{
+            rmSync(temporaryCompiler, {
+                force: true
+            });
+        }
+    }
+    accessSync(executableCompiler, constants.X_OK);
+    executableEffectTsgoCompilers.set(sourcePath, executableCompiler);
+    return executableCompiler;
+}
+function getBuildConfigEnvironment(name) {
+    return process.env[name];
+}
+function withBuildConfigEnvironment(name, value, setup) {
+    return async (config, ...args)=>{
+        const release = acquireEnvironmentLease(name, value);
+        try {
+            const configured = await setup(config, ...args) ?? config;
+            configured.plugins = [
+                ...configured.plugins ?? [],
+                new BuildConfigEnvironmentLeasePlugin(release)
+            ];
+            return configured;
+        } catch (error) {
+            releaseAfterFailure(release, error);
+        }
+    };
+}
+function resolveEffectTsgoCompiler(options) {
+    const configuredCompiler = getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
+    if (configuredCompiler) try {
+        return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+    } catch  {
+        throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    }
+    try {
+        const compiler = execFileSync(process.execPath, [
+            resolveEffectTsgoCli(options.from),
+            'get-exe-path'
+        ], {
+            encoding: 'utf-8'
+        }).trim();
+        if (compiler) return resolveExecutableEffectTsgoCompiler(compiler);
+    } catch  {}
+    throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+}
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment };

package/dist/esm-node/config/default.mjs

@@ -1,8 +1,10 @@
 import "node:module";
+import { AGGRED_DIR } from "@modern-js/server-core";
 import { DEFAULT_ENTRY_NAME } from "@modern-js/utils";
 import { getAutoInjectEnv } from "../utils/env.mjs";
 function createDefaultConfig(appContext) {
     const dev = {
+        mockDir: `./${AGGRED_DIR.mock}`,
         cliShortcuts: {
             help: false,
             custom: (shortcuts = [])=>shortcuts.filter(({ key })=>'r' !== key && 'u' !== key && 'o' !== key)

package/dist/esm-node/config/index.mjs

@@ -1,3 +1,4 @@
 import "node:module";
+export * from "./build-environment.mjs";
 export * from "./default.mjs";
 export * from "./initialize/index.mjs";

package/dist/esm-node/config/public.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment } from "./build-environment.mjs";

package/dist/esm-node/index.mjs

@@ -5,22 +5,22 @@ import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
 import { createAsyncHook } from "@modern-js/plugin";
 import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
 import path from "path";
-import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, runtimeCommand, serverCommand } from "./commands/index.mjs";
+import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand } from "./commands/index.mjs";
 import { compatPlugin } from "./compat/index.mjs";
 import { DEFAULT_RUNTIME_CONFIG_FILE } from "./constants.mjs";
 import { i18n } from "./locale/index.mjs";
 import analyze from "./plugins/analyze/index.mjs";
+import backendFederationBuild from "./plugins/backendFederationBuild.mjs";
 import deploy from "./plugins/deploy/index.mjs";
 import initialize from "./plugins/initialize/index.mjs";
 import serverBuild from "./plugins/serverBuild.mjs";
 import serverRuntime from "./plugins/serverRuntime.mjs";
+import ultramodernReleaseEnvelope from "./plugins/ultramodernReleaseEnvelope.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
-export * from "./baseline.mjs";
 export * from "./defineConfig.mjs";
 export * from "./presetUltramodern.mjs";
-export * from "./ultramodern/designSystem.mjs";
 export * from "./types/index.mjs";
 const appTools = ()=>({
         name: '@modern-js/app-tools',
@@ -30,6 +30,8 @@ const appTools = ()=>({
             initialize(),
             analyze(),
             serverBuild(),
+            backendFederationBuild(),
+            ultramodernReleaseEnvelope(),
             deploy()
         ],
         post: [
@@ -74,7 +76,6 @@ const appTools = ()=>({
                 deployCommand(program, api);
                 inspectCommand(program, api);
                 infoCommand(program, api);
-                await runtimeCommand(program, api);
                 deprecatedCommands(program);
             });
             api.onPrepare(async ()=>{
@@ -86,7 +87,18 @@ const appTools = ()=>({
                     ].some((tag)=>getArgv().includes(tag));
                     if (isSkipBuild) return;
                 }
-                if ('dev' === command || 'start' === command || 'build' === command || 'deploy' === command) {
+                const { command: contextCommand } = api.getAppContext();
+                const shouldClean = [
+                    'dev',
+                    'start',
+                    'build',
+                    'deploy'
+                ].includes(command) || [
+                    'dev',
+                    'start',
+                    'build'
+                ].includes(contextCommand);
+                if (shouldClean) {
                     const resolvedConfig = api.getNormalizedConfig();
                     if (resolvedConfig.output.cleanDistPath) {
                         const appContext = api.getAppContext();
@@ -126,9 +138,12 @@ const appTools = ()=>({
     });
 const src = appTools;
 export { defineConfig } from "./defineConfig.mjs";
+export { build } from "./commands/build.mjs";
+export { deploy } from "./commands/deploy.mjs";
 export { dev } from "./commands/dev.mjs";
 export { serve } from "./commands/serve.mjs";
 export { resolveModernRsbuildConfig } from "./rsbuild.mjs";
+export { closeServer } from "./utils/createServer.mjs";
 export { mergeConfig } from "@modern-js/plugin/cli";
 export default src;
 export { appTools, generateWatchFiles, initAppContext };

package/dist/esm-node/plugins/analyze/getHtmlTemplate.mjs

@@ -2,7 +2,7 @@ import "node:module";
 import { findExists, fs } from "@modern-js/utils";
 import path from "path";
 import { HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER } from "./constants.mjs";
-import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
+import * as __rspack_external__templates_mjs_ab577925 from "./templates.mjs";
 const findPartials = (dir, entryName, position)=>{
     if (fs.existsSync(dir)) {
         const base = findExists(HTML_PARTIALS_EXTENSIONS.map((ext)=>path.resolve(dir, `${position}${ext}`)));
@@ -83,7 +83,7 @@ const getHtmlTemplate = async (entrypoints, hooks, { appContext, config })=>{
                 partials: getModifyHtmlPartials(partials)
             });
             const templatePath = path.resolve(internalDirectory, entryName, 'index.html');
-            fs.outputFileSync(templatePath, __rspack_external__templates_mjs_4da4c6c8.html(partials), 'utf8');
+            fs.outputFileSync(templatePath, __rspack_external__templates_mjs_ab577925.html(partials), 'utf8');
             htmlTemplates[entryName] = templatePath.replace(/\\/g, '/');
             partialsByEntrypoint[entryName] = partials;
             const bottomTemplate = findPartials(htmlDir, name, "bottom");

package/dist/esm-node/plugins/analyze/getServerRoutes.mjs

@@ -128,4 +128,20 @@ const getProdServerRoutes = (distDirectory)=>{
         throw new Error(`Failed to read routes from ${routeJSON}, please check if the file exists.`);
     }
 };
-export { getProdServerRoutes, getServerRoutes };
+const getProdEntrypoints = (distDirectory, routes, mainEntryName = MAIN_ENTRY_NAME)=>{
+    const byEntryName = new Map();
+    for (const route of routes){
+        if (!route.entryName || byEntryName.has(route.entryName)) continue;
+        const builtEntry = route.bundle || route.entryPath;
+        byEntryName.set(route.entryName, {
+            entryName: route.entryName,
+            entry: path.resolve(distDirectory, builtEntry),
+            isAutoMount: true,
+            isMainEntry: route.entryName === mainEntryName
+        });
+    }
+    return [
+        ...byEntryName.values()
+    ];
+};
+export { getProdEntrypoints, getProdServerRoutes, getServerRoutes };

package/dist/esm-node/plugins/analyze/index.mjs

@@ -24,10 +24,10 @@ const analyze = ()=>({
                 const resolvedConfig = api.getNormalizedConfig();
                 const hooks = api.getHooks();
                 try {
-                    if (checkIsBuildCommands()) fs.emptydirSync(appContext.internalDirectory);
+                    if (checkIsBuildCommands(appContext.command)) fs.emptydirSync(appContext.internalDirectory);
                 } catch  {}
                 const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
-                const [{ getProdServerRoutes }] = await Promise.all([
+                const [{ getProdEntrypoints, getProdServerRoutes }] = await Promise.all([
                     import("./getServerRoutes.mjs")
                 ]);
                 if (apiOnly) {
@@ -46,6 +46,17 @@ const analyze = ()=>({
                     });
                     return;
                 }
+                if (checkIsServeCommand()) {
+                    const routes = getProdServerRoutes(appContext.distDirectory);
+                    const entrypoints = getProdEntrypoints(appContext.distDirectory, routes, resolvedConfig.source.mainEntryName);
+                    api.updateAppContext({
+                        apiOnly,
+                        checkedEntries: entrypoints.map((entrypoint)=>entrypoint.entryName),
+                        entrypoints,
+                        serverRoutes: routes
+                    });
+                    return;
+                }
                 const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
                     import("./getBundleEntry.mjs"),
                     import("./getServerRoutes.mjs"),
@@ -56,17 +67,14 @@ const analyze = ()=>({
                 });
                 debug("entrypoints: %o", entrypoints);
                 const routes = [];
-                if (checkIsServeCommand()) routes.push(...getProdServerRoutes(appContext.distDirectory));
-                else {
-                    const initialRoutes = getServerRoutes(entrypoints, {
-                        appContext,
-                        config: resolvedConfig
-                    });
-                    const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
-                        routes: initialRoutes
-                    });
-                    routes.push(...modifiedRoutes);
-                }
+                const initialRoutes = getServerRoutes(entrypoints, {
+                    appContext,
+                    config: resolvedConfig
+                });
+                const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                    routes: initialRoutes
+                });
+                routes.push(...modifiedRoutes);
                 debug("server routes: %o", routes);
                 appContext = {
                     ...api.getAppContext(),
@@ -118,7 +126,7 @@ const analyze = ()=>({
                     htmlTemplates
                 };
                 api.updateAppContext(appContext);
-                if (checkIsBuildCommands()) {
+                if (checkIsBuildCommands(appContext.command)) {
                     await hooks.generateEntryCode.call({
                         entrypoints
                     });