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

package/dist/esm/builder/shared/builderPlugins/adapterSSR.mjs

@@ -2,7 +2,7 @@ import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/buil
 import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
-import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import { CssExtractRuntimePlugin, HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
 import * as __rspack_external_path from "path";
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
@@ -63,17 +63,20 @@ function applyRouterPlugin(chain, pluginName, options, HtmlBundlerPlugin) {
     const workerSSR = Boolean(normalizedConfig.deploy.worker?.ssr);
     const { enableInlineRouteManifests, disableInlineRouteManifests } = normalizedConfig.output;
     const inlineRouteManifests = disableInlineRouteManifests ? !disableInlineRouteManifests : enableInlineRouteManifests;
-    if (existNestedRoutes || workerSSR) chain.plugin(pluginName).use(RouterPlugin, [
-        {
-            HtmlBundlerPlugin,
-            enableInlineRouteManifests: inlineRouteManifests,
-            staticJsDir: normalizedConfig.output?.distPath?.js,
-            disableFilenameHash: normalizedConfig.output?.filenameHash === false,
-            scriptLoading: normalizedConfig.html?.scriptLoading,
-            nonce: normalizedConfig.security?.nonce,
-            useRsc: isUseRsc(normalizedConfig)
-        }
-    ]);
+    if (existNestedRoutes || workerSSR) {
+        chain.plugin(`${pluginName}-css-extract-runtime`).use(CssExtractRuntimePlugin);
+        chain.plugin(pluginName).use(RouterPlugin, [
+            {
+                HtmlBundlerPlugin,
+                enableInlineRouteManifests: inlineRouteManifests,
+                staticJsDir: normalizedConfig.output?.distPath?.js,
+                disableFilenameHash: normalizedConfig.output?.filenameHash === false,
+                scriptLoading: normalizedConfig.html?.scriptLoading,
+                nonce: normalizedConfig.security?.nonce,
+                useRsc: isUseRsc(normalizedConfig)
+            }
+        ]);
+    }
 }
 function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
     const { server: serverConfig, output: outputConfig } = appNormalizedConfig;

package/dist/esm/builder/shared/bundlerPlugins/CssExtractRuntimePlugin.mjs

@@ -0,0 +1,30 @@
+const PLUGIN_NAME = 'ModernjsCssExtractRuntimePlugin';
+const CSS_LOADING_RUNTIME_MODULE = 'webpack/runtime/css loading';
+const CSS_EXTRACT_STYLESHEET_MATCH = '\t\tif (tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref)) return tag;';
+const CSS_EXTRACT_STYLESHEET_MATCH_WITH_NORMALIZED_URL = `\t\tvar absoluteHref = tag.href;
+\t\tvar absoluteFullHref = new URL(fullhref, document.baseURI).href;
+\t\tif (tag.rel === "stylesheet" && (dataHref === href || dataHref === fullhref || absoluteHref === absoluteFullHref)) return tag;`;
+const isAutomaticPublicPath = (publicPath)=>'auto' === publicPath || 'auto/' === publicPath;
+const normalizeCssExtractRuntimeStylesheetLookup = (source)=>{
+    if (!source.includes('__webpack_require__.miniCssF')) return source;
+    const occurrences = source.split(CSS_EXTRACT_STYLESHEET_MATCH).length - 1;
+    if (1 !== occurrences) throw new Error(`Unsupported CssExtractRspackPlugin runtime shape: expected one stylesheet lookup, found ${occurrences}.`);
+    return source.replace(CSS_EXTRACT_STYLESHEET_MATCH, CSS_EXTRACT_STYLESHEET_MATCH_WITH_NORMALIZED_URL);
+};
+class CssExtractRuntimePlugin {
+    apply(compiler) {
+        if (!isAutomaticPublicPath(compiler.options.output.publicPath)) return;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (runtimeModule)=>{
+                if (runtimeModule.identifier() !== CSS_LOADING_RUNTIME_MODULE) return;
+                const runtimeSource = runtimeModule.source?.source;
+                if ('string' != typeof runtimeSource) return;
+                runtimeModule.source.source = normalizeCssExtractRuntimeStylesheetLookup(runtimeSource);
+            });
+        });
+    }
+    constructor(){
+        this.name = PLUGIN_NAME;
+    }
+}
+export { CssExtractRuntimePlugin, normalizeCssExtractRuntimeStylesheetLookup };

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

@@ -4,6 +4,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;
@@ -29,15 +36,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);
@@ -57,6 +70,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);
@@ -78,7 +92,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);
@@ -88,7 +102,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));
@@ -143,7 +157,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;
                     })};
@@ -160,7 +174,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);
@@ -183,4 +197,4 @@ class RouterPlugin {
         this.useRsc = useRsc;
     }
 }
-export { RouterPlugin };
+export { RouterPlugin, normalizeRouterAssetPublicPath };

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

@@ -1,3 +1,4 @@
+export * from "./CssExtractRuntimePlugin.mjs";
 export * from "./HtmlAsyncChunkPlugin.mjs";
 export * from "./HtmlBottomTemplate.mjs";
 export * from "./RouterPlugin.mjs";

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

@@ -20,7 +20,6 @@ function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
-const buildSSRLazyCompilationTest = buildRouteEagerLazyCompilationTest;
 function planRouteEagerLazyCompilation(current, info) {
     if (!current) return {
         apply: false
@@ -42,5 +41,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/bundleDocs.mjs

@@ -0,0 +1,62 @@
+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/commands/build.mjs

@@ -56,8 +56,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/commands/deploy.mjs

@@ -1,8 +1,10 @@
 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/commands/index.mjs

@@ -19,10 +19,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);
@@ -40,5 +36,4 @@ const infoCommand = (program, api)=>{
         await info(api, options);
     });
 };
-export { runtimeCommand } from "./runtime.mjs";
 export { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand };

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

@@ -0,0 +1,224 @@
+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/config/default.mjs

@@ -1,7 +1,9 @@
+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/config/index.mjs

@@ -1,2 +1,3 @@
+export * from "./build-environment.mjs";
 export * from "./default.mjs";
 export * from "./initialize/index.mjs";

package/dist/esm/config/public.mjs

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

package/dist/esm/index.mjs

@@ -3,22 +3,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',
@@ -28,6 +28,8 @@ const appTools = ()=>({
             initialize(),
             analyze(),
             serverBuild(),
+            backendFederationBuild(),
+            ultramodernReleaseEnvelope(),
             deploy()
         ],
         post: [
@@ -72,7 +74,6 @@ const appTools = ()=>({
                 deployCommand(program, api);
                 inspectCommand(program, api);
                 infoCommand(program, api);
-                await runtimeCommand(program, api);
                 deprecatedCommands(program);
             });
             api.onPrepare(async ()=>{
@@ -84,7 +85,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();
@@ -124,9 +136,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/plugins/analyze/getHtmlTemplate.mjs

@@ -1,7 +1,7 @@
 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}`)));
@@ -82,7 +82,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/plugins/analyze/getServerRoutes.mjs

@@ -127,4 +127,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 };