@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.98 → 3.8.1-ultramodern.1

package/dist/esm/ultramodern-release-envelope/framework-output.mjs

@@ -1,42 +1,15 @@
+import { createHash } from "node:crypto";
 import promises from "node:fs/promises";
 import node_path from "node:path";
-import { parse } from "@babel/parser";
 import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, isUltramodernBuildArtifact } from "@modern-js/utils/universal";
 import { canonicalSerializeMicroVerticalReleaseEnvelope, createMicroVerticalReleaseEnvelope, verifyMicroVerticalReleaseEnvelope } from "./index.mjs";
 const MICROVERTICAL_RELEASE_ENVELOPE_PATH = 'release/microvertical-release-envelope.json';
+const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH = 'release/microvertical-release-identity-carriers.json';
+const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_KIND = 'ultramodern-release-identity-carriers';
+const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_SCHEMA_VERSION = 1;
 const COMPILED_MODULE_PATTERN = /\.(?:c|m)?js$/u;
 const EFFECT_BFF_WORKER_PATTERN = /^worker\/__modern_bff_effect\.(?:c|m)?js$/u;
 const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-const isAstNode = (value)=>isRecord(value) && 'string' == typeof value.type;
-const visitAst = (node, visitor)=>{
-    visitor(node);
-    for (const value of Object.values(node))if (isAstNode(value)) visitAst(value, visitor);
-    else if (Array.isArray(value)) {
-        for (const item of value)if (isAstNode(item)) visitAst(item, visitor);
-    }
-};
-const compiledModuleIdentityValues = (source)=>{
-    const values = new Set();
-    const ast = parse(source, {
-        sourceType: 'unambiguous'
-    });
-    visitAst(ast.program, (node)=>{
-        if ('StringLiteral' === node.type && 'string' == typeof node.value) values.add(node.value);
-        else if ('TemplateElement' === node.type && isRecord(node.value) && 'string' == typeof node.value.cooked) values.add(node.value.cooked);
-    });
-    return values;
-};
-const assertEveryCompiledIdentityCarrier = async (distDirectory, logicalPaths, identity, surface)=>{
-    const compiledLogicalPaths = logicalPaths.filter((pathname)=>COMPILED_MODULE_PATTERN.test(pathname));
-    if (0 === compiledLogicalPaths.length) throw new Error(`[ultramodern-release-envelope] ${surface} has no compiled execution module carrying release identity.`);
-    for (const logicalPath of compiledLogicalPaths){
-        const source = await promises.readFile(node_path.join(distDirectory, logicalPath), {
-            encoding: 'utf8'
-        });
-        const values = compiledModuleIdentityValues(source);
-        if (!values.has(identity.buildMarker) || !values.has(identity.sourceRevision) || !values.has(identity.releaseVersion)) throw new Error(`[ultramodern-release-envelope] ${surface} execution module ${logicalPath} does not carry exact buildMarker ${identity.buildMarker}, sourceRevision ${identity.sourceRevision}, and releaseVersion ${identity.releaseVersion}.`);
-    }
-};
 const flattenStrings = (value)=>'string' == typeof value ? [
         value
     ] : Array.isArray(value) ? value.flatMap(flattenStrings) : [];
@@ -179,6 +152,49 @@ const releaseArtifact = (logicalPath, runtime)=>({
         logicalPath,
         runtime
     });
+const writeReleaseIdentityCarrierMetadata = async (artifactRoot, identity, carrierPaths)=>{
+    const surfacesByPath = new Map();
+    for (const [surface, logicalPaths] of Object.entries(carrierPaths)){
+        if (0 === logicalPaths.length) throw new Error(`[ultramodern-release-envelope] ${surface} has no declared release-identity carrier artifact.`);
+        for (const logicalPath of logicalPaths){
+            const surfaces = surfacesByPath.get(logicalPath) ?? new Set();
+            surfaces.add(surface);
+            surfacesByPath.set(logicalPath, surfaces);
+        }
+    }
+    const carriers = await Promise.all([
+        ...surfacesByPath
+    ].sort(([left], [right])=>left.localeCompare(right)).map(async ([logicalPath, surfaces])=>{
+        const bytes = await promises.readFile(node_path.join(artifactRoot, logicalPath));
+        return {
+            logicalPath,
+            byteLength: bytes.byteLength,
+            sha256: createHash('sha256').update(bytes).digest('hex'),
+            surfaces: [
+                ...surfaces
+            ].sort((left, right)=>left.localeCompare(right))
+        };
+    }));
+    const releaseEnvelopePath = await resolveSafeReleaseEnvelopePath({
+        artifactRoot,
+        createDirectory: true
+    });
+    if (!releaseEnvelopePath) throw new Error('[ultramodern-release-envelope] could not resolve private release metadata directory.');
+    const metadataPath = node_path.join(node_path.dirname(releaseEnvelopePath), node_path.basename(MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH));
+    try {
+        const metadataStat = await promises.lstat(metadataPath);
+        if (metadataStat.isSymbolicLink() || !metadataStat.isFile()) throw new Error('[ultramodern-release-envelope] release identity carrier metadata must be a real file inside artifactRoot.');
+    } catch (error) {
+        if (!isMissingPathError(error)) throw error;
+    }
+    await promises.writeFile(metadataPath, `${JSON.stringify({
+        schemaVersion: MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_SCHEMA_VERSION,
+        kind: MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_KIND,
+        identity,
+        carriers
+    }, null, 2)}\n`);
+    return releaseArtifact(MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH, 'release-identity-metadata');
+};
 const createReleaseArtifactInputs = async (distDirectory, identity, target)=>{
     const files = await collectFiles(distDirectory);
     if ('node' === target && files.some((logicalPath)=>EFFECT_BFF_WORKER_PATTERN.test(logicalPath))) throw new Error('[ultramodern-release-envelope] Node target conflicts with a Cloudflare Effect API/BFF worker artifact; resolve the canonical deploy target instead of emitting a Node envelope for Cloudflare output.');
@@ -202,13 +218,7 @@ const createReleaseArtifactInputs = async (distDirectory, identity, target)=>{
     const clientExecutionPaths = await manifestReferencedClientModules(distDirectory, files);
     if (0 === clientExecutionPaths.length) throw new Error('[ultramodern-release-envelope] UI/client manifest references no compiled execution module.');
     const ssrExecutionPaths = await routeReferencedSsrModules(distDirectory, files, target);
-    await assertEveryCompiledIdentityCarrier(distDirectory, clientExecutionPaths, identity, 'manifest-referenced UI/client');
-    await assertEveryCompiledIdentityCarrier(distDirectory, ssrExecutionPaths, identity, 'node' === target ? 'route-referenced Node SSR' : 'route-referenced Cloudflare SSR');
-    await assertEveryCompiledIdentityCarrier(distDirectory, ssrPaths, identity, 'node' === target ? 'compiled Node SSR closure' : 'compiled Cloudflare SSR/workerd closure');
-    await assertEveryCompiledIdentityCarrier(distDirectory, 'node' === target ? nodeApiEntryPaths : apiBackendPaths, identity, 'node' === target ? 'Node API/backend' : 'Cloudflare API/backend');
-    await assertEveryCompiledIdentityCarrier(distDirectory, [
-        BACKEND_FEDERATION_REMOTE_ENTRY_FILE
-    ], identity, 'backend Module Federation container');
+    if (0 === ssrExecutionPaths.length) throw new Error(`[ultramodern-release-envelope] route manifest references no emitted ${'node' === target ? 'Node' : 'Cloudflare'} SSR execution module.`);
     const runtimeByPath = new Map();
     const add = (paths, runtime)=>{
         for (const logicalPath of paths){
@@ -244,8 +254,25 @@ const createReleaseArtifactInputs = async (distDirectory, identity, target)=>{
     const artifacts = [
         ...runtimeByPath
     ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)).sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath));
+    const identityCarrierMetadata = await writeReleaseIdentityCarrierMetadata(distDirectory, identity, {
+        apiBackend: apiBackendPaths,
+        backendFederation: [
+            BACKEND_FEDERATION_MANIFEST_FILE,
+            BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+        ],
+        ssr: [
+            ...new Set([
+                ...ssrExecutionPaths,
+                ...ssrPaths
+            ])
+        ],
+        uiClient: uiClientPaths.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath))
+    });
     return {
-        artifacts,
+        artifacts: [
+            ...artifacts,
+            identityCarrierMetadata
+        ].sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath)),
         surfaces
     };
 };
@@ -367,13 +394,7 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity)=
     ])if (0 === paths.length) throw new Error(`[ultramodern-release-envelope] final Node staging has no ${surface} artifacts.`);
     const clientExecutionPaths = await manifestReferencedClientModules(outputDirectory, files);
     const ssrExecutionPaths = await routeReferencedSsrModules(outputDirectory, files, 'node');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, clientExecutionPaths, identity, 'final manifest-referenced Node UI/client');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrExecutionPaths, identity, 'final route-referenced Node SSR');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrPaths.filter((logicalPath)=>'index.js' !== logicalPath), identity, 'final compiled Node SSR closure');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, apiBackendPaths.filter((logicalPath)=>logicalPath.startsWith('api/')), identity, 'final Node API/backend');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, [
-        BACKEND_FEDERATION_REMOTE_ENTRY_FILE
-    ], identity, 'final Node backend Module Federation container');
+    if (0 === clientExecutionPaths.length || 0 === ssrExecutionPaths.length) throw new Error('[ultramodern-release-envelope] final Node manifests must reference emitted UI/client and SSR execution modules.');
     const runtimeByPath = new Map(files.filter((logicalPath)=>!backendFederationPaths.has(logicalPath)).map((logicalPath)=>[
             logicalPath,
             'nodejs-deployment'
@@ -383,10 +404,27 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity)=
     for (const logicalPath of apiBackendPaths)runtimeByPath.set(logicalPath, 'nodejs');
     runtimeByPath.set(BACKEND_FEDERATION_MANIFEST_FILE, 'module-federation-manifest');
     runtimeByPath.set(BACKEND_FEDERATION_REMOTE_ENTRY_FILE, 'nodejs');
+    const identityCarrierMetadata = await writeReleaseIdentityCarrierMetadata(outputDirectory, identity, {
+        apiBackend: apiBackendPaths,
+        backendFederation: [
+            BACKEND_FEDERATION_MANIFEST_FILE,
+            BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+        ],
+        ssr: [
+            ...new Set([
+                ...ssrExecutionPaths,
+                ...ssrPaths.filter((logicalPath)=>'index.js' !== logicalPath)
+            ])
+        ],
+        uiClient: uiClientPaths.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath))
+    });
     return {
         artifacts: [
-            ...runtimeByPath
-        ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)).sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath)),
+            ...[
+                ...runtimeByPath
+            ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)),
+            identityCarrierMetadata
+        ].sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath)),
         surfaces: {
             uiClient: [
                 ...uiClientPaths
@@ -460,13 +498,7 @@ const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, iden
     ])if (!files.includes(logicalPath)) throw new Error(`[ultramodern-release-envelope] final Cloudflare staging is missing ${logicalPath}.`);
     const clientExecutionPaths = await manifestReferencedClientModules(outputDirectory, files, 'public/mf-manifest.json');
     const ssrExecutionPaths = await routeReferencedSsrModules(outputDirectory, files, 'cloudflare', 'server/route.json');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, clientExecutionPaths, identity, 'final manifest-referenced Cloudflare UI/client');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrExecutionPaths, identity, 'final route-referenced Cloudflare SSR');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, ssrPaths.filter((logicalPath)=>logicalPath.startsWith('worker/')), identity, 'final compiled Cloudflare SSR/workerd closure');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, apiBackendPaths, identity, 'final Cloudflare API/backend');
-    await assertEveryCompiledIdentityCarrier(outputDirectory, [
-        backendContainerPath
-    ], identity, 'final Cloudflare backend Module Federation container');
+    if (0 === clientExecutionPaths.length || 0 === ssrExecutionPaths.length) throw new Error('[ultramodern-release-envelope] final Cloudflare manifests must reference emitted UI/client and SSR execution modules.');
     const runtimeByPath = new Map();
     for (const logicalPath of files)runtimeByPath.set(logicalPath, 'cloudflare-deployment');
     const add = (paths, runtime)=>{
@@ -481,10 +513,27 @@ const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, iden
     add([
         backendContainerPath
     ], 'commonjs-module');
+    const identityCarrierMetadata = await writeReleaseIdentityCarrierMetadata(outputDirectory, identity, {
+        apiBackend: apiBackendPaths,
+        backendFederation: [
+            backendManifestPath,
+            backendContainerPath
+        ],
+        ssr: [
+            ...new Set([
+                ...ssrExecutionPaths,
+                ...ssrPaths.filter((logicalPath)=>logicalPath.startsWith('worker/'))
+            ])
+        ],
+        uiClient: uiClientPaths.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath))
+    });
     return {
         artifacts: [
-            ...runtimeByPath
-        ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)).sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath)),
+            ...[
+                ...runtimeByPath
+            ].map(([logicalPath, runtime])=>releaseArtifact(logicalPath, runtime)),
+            identityCarrierMetadata
+        ].sort((left, right)=>left.logicalPath.localeCompare(right.logicalPath)),
         surfaces: {
             uiClient: [
                 ...uiClientPaths
@@ -521,4 +570,4 @@ const verifyCloudflareReleaseEnvelopeStaging = async (outputDirectory)=>readFram
         expectedTarget: 'cloudflare',
         required: true
     });
-export { MICROVERTICAL_RELEASE_ENVELOPE_PATH, emitCloudflareStagedReleaseEnvelope, emitFrameworkMicroVerticalReleaseEnvelope, emitNodeStagedReleaseEnvelope, readFrameworkMicroVerticalReleaseEnvelope, stageCloudflareReleaseEnvelope, verifyBuildOutputReleaseEnvelope, verifyCloudflareReleaseEnvelopeStaging, verifyNodeReleaseEnvelopeStaging };
+export { MICROVERTICAL_RELEASE_ENVELOPE_PATH, MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH, emitCloudflareStagedReleaseEnvelope, emitFrameworkMicroVerticalReleaseEnvelope, emitNodeStagedReleaseEnvelope, readFrameworkMicroVerticalReleaseEnvelope, stageCloudflareReleaseEnvelope, verifyBuildOutputReleaseEnvelope, verifyCloudflareReleaseEnvelopeStaging, verifyNodeReleaseEnvelopeStaging };

package/dist/esm-node/builder/generator/createBuilderProviderConfig.mjs

@@ -15,6 +15,10 @@ function modifyOutputConfig(config, appContext) {
     };
 }
 function createBuilderProviderConfig(resolveConfig, appContext) {
+    const builderDevConfig = {
+        ...resolveConfig.dev
+    };
+    delete builderDevConfig.mockDir;
     const htmlConfig = {
         ...resolveConfig.html
     };
@@ -33,7 +37,7 @@ function createBuilderProviderConfig(resolveConfig, appContext) {
             ...resolveConfig.source
         },
         dev: {
-            ...resolveConfig.dev,
+            ...builderDevConfig,
             port: appContext.port
         },
         server: serverConfig,

package/dist/esm-node/builder/generator/getBuilderEnvironments.mjs

@@ -10,6 +10,8 @@ import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
 const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
 const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
+const MF_SSR_DATA_FETCH_RUNTIME_PLUGIN = '@module-federation/modern-js-v3/ssr-inject-data-fetch-function-plugin';
+const MF_SSR_DEV_RUNTIME_PLUGIN = '@module-federation/modern-js-v3/ssr-dev-plugin';
 const JS_OR_TS_EXTS = [
     '.js',
     '.jsx',
@@ -44,6 +46,13 @@ function resolvePackageFile(packageName, filePath, paths) {
             paths
         }));
     } catch  {
+        try {
+            const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+                paths
+            });
+            const packageFile = node_path.join(node_path.dirname(packageJsonPath), filePath);
+            if (node_fs.existsSync(packageFile)) return node_fs.realpathSync(packageFile);
+        } catch  {}
         const packageEntry = resolvePackageEntry(packageName, paths);
         if (!packageEntry) return;
         const packageRoot = findPackageRoot(packageEntry, packageName);
@@ -83,6 +92,64 @@ function getCloudflareWorkerNodeExternals() {
         ];
     }));
 }
+const reserveWorkerChunkName = (baseName, reservedOutputNames)=>{
+    let name = baseName;
+    while(reservedOutputNames.has(normalizeWorkerOutputName(name)))name = `${name}_`;
+    return name;
+};
+const normalizeWorkerOutputName = (name)=>node_path.posix.normalize(name.replace(/\\/gu, '/')).toLowerCase();
+function getCloudflareWorkerRspackConfig(workerEntryNames) {
+    const entryNames = [
+        ...workerEntryNames
+    ];
+    for (const entryName of entryNames){
+        const slashName = entryName.replace(/\\/gu, '/');
+        const normalizedName = node_path.posix.normalize(slashName);
+        if (entryName !== slashName || normalizedName !== slashName || '.' === normalizedName || normalizedName.startsWith('../') || node_path.posix.isAbsolute(normalizedName) || node_path.win32.isAbsolute(slashName) || /^[A-Za-z]:/u.test(slashName)) throw new Error(`Cloudflare worker entry name "${entryName}" must be a canonical relative output path without dot segments or backslashes.`);
+    }
+    const reservedNames = new Set(entryNames.map(normalizeWorkerOutputName));
+    const runtimeName = reserveWorkerChunkName('__modern_worker_runtime', reservedNames);
+    reservedNames.add(normalizeWorkerOutputName(runtimeName));
+    const sharedName = reserveWorkerChunkName('__modern_worker_shared', reservedNames);
+    return {
+        experiments: {
+            outputModule: true
+        },
+        externals: getCloudflareWorkerNodeExternals(),
+        externalsType: 'module-import',
+        module: {
+            parser: {
+                javascript: {
+                    dynamicImportMode: 'eager'
+                }
+            }
+        },
+        optimization: {
+            runtimeChunk: {
+                name: runtimeName
+            },
+            splitChunks: {
+                chunks: 'all',
+                minSize: 0,
+                name: sharedName
+            }
+        }
+    };
+}
+function applyCloudflareWorkerRspackConfig(chain, workerEntryNames) {
+    const config = getCloudflareWorkerRspackConfig(workerEntryNames);
+    chain.experiments(config.experiments);
+    chain.externals(config.externals);
+    chain.externalsType(config.externalsType);
+    chain.module.parser.merge(config.module.parser);
+    chain.optimization.runtimeChunk(config.optimization.runtimeChunk);
+    chain.optimization.splitChunks(config.optimization.splitChunks);
+}
+function applyCloudflareWorkerMfRuntimeBoundary(chain) {
+    chain.plugins.delete('plugin-module-federation');
+    chain.resolve.alias.set(`${MF_SSR_DATA_FETCH_RUNTIME_PLUGIN}$`, getCloudflareWorkerCompatFile('cloudflare-worker-mf-ssr-runtime-plugin.mjs'));
+    chain.resolve.alias.set(`${MF_SSR_DEV_RUNTIME_PLUGIN}$`, getCloudflareWorkerCompatFile('cloudflare-worker-mf-ssr-runtime-plugin.mjs'));
+}
 function getEffectBffEntry(normalizedConfig, appContext) {
     if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
     const configuredEntry = normalizedConfig.bff.effect?.entry;
@@ -241,17 +308,10 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
                 htmlPlugin: false,
                 ...useCloudflareModuleWorker ? {
                     bundlerChain: (chain)=>{
-                        chain.merge({
-                            experiments: {
-                                outputModule: true
-                            },
-                            externals: getCloudflareWorkerNodeExternals(),
-                            externalsType: 'module-import'
-                        });
+                        applyCloudflareWorkerRspackConfig(chain, Object.keys(workerEntries));
                         chain.output.module(true).library({
                             type: 'module'
                         }).publicPath('/').chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
-                        chain.optimization.usedExports(false).providedExports(true).innerGraph(false).sideEffects(false);
                         for (const condition of [
                             'workerd',
                             'worker',
@@ -261,7 +321,7 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
                             'require',
                             'module'
                         ])chain.resolve.conditionNames.add(condition);
-                        chain.plugins.delete('plugin-module-federation');
+                        applyCloudflareWorkerMfRuntimeBoundary(chain);
                         if (tanstackRouterSsrServerFile) {
                             chain.resolve.alias.set('@tanstack/router-core/ssr/server$', tanstackRouterSsrServerFile);
                             chain.resolve.alias.set('@tanstack/router-core/ssr/server', tanstackRouterSsrServerFile);
@@ -302,4 +362,4 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
         builderConfig: tempBuilderConfig
     };
 }
-export { getBuilderEnvironments };
+export { applyCloudflareWorkerMfRuntimeBoundary, applyCloudflareWorkerRspackConfig, getBuilderEnvironments, getCloudflareWorkerRspackConfig };

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);

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/index.mjs

@@ -87,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();
@@ -127,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/index.mjs

@@ -24,7 +24,7 @@ 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 [{ getProdEntrypoints, getProdServerRoutes }] = await Promise.all([
@@ -126,7 +126,7 @@ const analyze = ()=>({
                     htmlTemplates
                 };
                 api.updateAppContext(appContext);
-                if (checkIsBuildCommands()) {
+                if (checkIsBuildCommands(appContext.command)) {
                     await hooks.generateEntryCode.call({
                         entrypoints
                     });

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

@@ -39,7 +39,7 @@ const parseModule = async ({ source, filename })=>{
     return await parse(content);
 };
 const getServerCombinedModuleFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
-const checkIsBuildCommands = ()=>{
+const checkIsBuildCommands = (contextCommand)=>{
     const buildCommands = [
         'dev',
         'start',
@@ -49,7 +49,8 @@ const checkIsBuildCommands = ()=>{
         'dev-worker'
     ];
     const command = getCommand();
-    return buildCommands.includes(command);
+    if (buildCommands.includes(command)) return true;
+    return 'dev' === contextCommand || 'start' === contextCommand || 'build' === contextCommand || 'deploy' === contextCommand;
 };
 const checkIsServeCommand = ()=>{
     const command = getCommand();

package/dist/esm-node/plugins/deploy/platforms/cloudflare-output-verifier/index.mjs

@@ -117,7 +117,7 @@ const verifyCloudflareOutput = async (options)=>{
             path: publicPath
         });
     }
-    if (false !== options.importWorker && await pathExists(outputPlan.paths.workerEntry)) await verifyWorkerImport(issues, outputPlan.paths.workerEntry);
+    if (false !== options.importWorker && await pathExists(outputPlan.paths.workerEntry)) await verifyWorkerImport(issues, outputPlan.paths.workerEntry, manifest);
     return {
         ok: 0 === issues.length,
         issues