@bleedingdev/modern-js-app-tools 3.8.3-ultramodern.1 → 3.8.3-ultramodern.2

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

@@ -4,33 +4,6 @@ import node_fs from "node:fs";
 import node_path from "node:path";
 import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/builder";
 import { isProd, isSSR, isServiceWorker, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
-import { CLOUDFLARE_WORKER_NODE_BUILTINS } from "../../plugins/deploy/platforms/cloudflare-output-contract.mjs";
-import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
-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',
-    '.ts',
-    '.tsx',
-    '.mjs',
-    '.mts',
-    '.cjs',
-    '.cts'
-];
-const CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR = node_path.resolve(__rspack_import_meta_dirname__, '../../plugins/deploy/platforms/templates');
-function findExistingFile(candidates) {
-    return candidates.find((candidate)=>node_fs.existsSync(candidate));
-}
-function resolveJsOrTsEntry(entryWithoutOrWithExt) {
-    const extension = node_path.extname(entryWithoutOrWithExt);
-    if (JS_OR_TS_EXTS.includes(extension)) return node_fs.existsSync(entryWithoutOrWithExt) ? entryWithoutOrWithExt : void 0;
-    return findExistingFile(JS_OR_TS_EXTS.map((extension)=>`${entryWithoutOrWithExt}${extension}`));
-}
 function resolvePackageEntry(packageName, paths) {
     try {
         return node_fs.realpathSync(require.resolve(packageName, {
@@ -74,94 +47,6 @@ function findPackageRoot(entryFile, packageName) {
 function setAliasIfPresent(alias, name, value) {
     if (value) alias.set(name, value);
 }
-function getCloudflareWorkerCompatFile(file) {
-    return node_path.join(CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR, file);
-}
-function getCloudflareWorkerNodeExternals() {
-    return Object.fromEntries(CLOUDFLARE_WORKER_NODE_BUILTINS.flatMap((builtin)=>{
-        const nodeBuiltin = `node:${builtin}`;
-        return [
-            [
-                builtin,
-                `module-import ${nodeBuiltin}`
-            ],
-            [
-                nodeBuiltin,
-                `module-import ${nodeBuiltin}`
-            ]
-        ];
-    }));
-}
-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;
-    if (configuredEntry) {
-        const entryWithoutOrWithExtension = node_path.isAbsolute(configuredEntry) ? configuredEntry : node_path.resolve(appContext.appDirectory, configuredEntry);
-        return resolveJsOrTsEntry(entryWithoutOrWithExtension);
-    }
-    return resolveJsOrTsEntry(node_path.resolve(appContext.apiDirectory, 'index'));
-}
-function isCloudflareWorkerDeploy(normalizedConfig) {
-    return normalizedConfig.deploy?.target === 'cloudflare' || 'cloudflare' === process.env.MODERNJS_DEPLOY;
-}
 function getConsumingReactRuntimeAliases(appContext) {
     const resolvePaths = [
         appContext.appDirectory,
@@ -215,11 +100,6 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
         const v = entries[entry];
         serverEntries[entry] = v.map((entry)=>entry.replace('index.jsx', 'index.server.jsx')).map((entry)=>entry.replace('bootstrap.jsx', 'bootstrap.server.jsx'));
     }
-    const cloudflareWorkerServerEntries = {};
-    for(const entry in entries){
-        const v = entries[entry];
-        cloudflareWorkerServerEntries[entry] = v.map((entry)=>entry.replace('index.jsx', 'index.server.jsx')).map((entry)=>entry.replace('bootstrap.jsx', 'index.server.jsx'));
-    }
     const environments = {
         client: {
             output: {
@@ -244,122 +124,20 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
         }
     };
     const useWorkerTarget = isServiceWorker(normalizedConfig);
-    if (useWorkerTarget) {
-        const useCloudflareModuleWorker = isCloudflareWorkerDeploy(normalizedConfig);
-        const effectApiEntry = useCloudflareModuleWorker ? getEffectBffEntry(normalizedConfig, appContext) : void 0;
-        const tanstackRouterSsrServerFile = useCloudflareModuleWorker ? resolvePackageFile('@tanstack/router-core', 'dist/esm/ssr/ssr-server.js', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const runtimeRscWorkerFile = useCloudflareModuleWorker ? resolvePackageFile('@modern-js/runtime', 'dist/esm/rsc/server.worker.mjs', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const renderRscWorkerFile = useCloudflareModuleWorker ? resolvePackageFile('@modern-js/render', 'dist/esm/rscWorker.mjs', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const reactFile = useCloudflareModuleWorker ? resolvePackageFile('react', 'index.js', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const reactJsxRuntimeFile = useCloudflareModuleWorker ? resolvePackageFile('react', 'jsx-runtime.js', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const reactJsxDevRuntimeFile = useCloudflareModuleWorker ? resolvePackageFile('react', 'jsx-dev-runtime.js', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const reactDomFile = useCloudflareModuleWorker ? resolvePackageFile('react-dom', 'index.js', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const reactDomServerEdgeFile = useCloudflareModuleWorker ? resolvePackageFile('react-dom', 'server.edge.js', [
-            appContext.appDirectory,
-            process.cwd()
-        ]) : void 0;
-        const loadableComponentFile = useCloudflareModuleWorker ? resolvePackageFile('@loadable/component', 'dist/esm/loadable.esm.mjs', [
-            appContext.appDirectory,
-            process.cwd(),
-            CLOUDFLARE_WORKER_COMPAT_TEMPLATE_DIR
-        ]) : void 0;
-        const loadableServerWorkerFile = useCloudflareModuleWorker ? getCloudflareWorkerCompatFile('cloudflare-worker-loadable-server.mjs') : void 0;
-        const fsPromisesWorkerFile = useCloudflareModuleWorker ? getCloudflareWorkerCompatFile('cloudflare-worker-fs-promises.mjs') : void 0;
-        const pathWorkerFile = useCloudflareModuleWorker ? getCloudflareWorkerCompatFile('cloudflare-worker-path.mjs') : void 0;
-        const baseWorkerEntries = useCloudflareModuleWorker ? cloudflareWorkerServerEntries : serverEntries;
-        const workerEntries = effectApiEntry ? {
-            ...baseWorkerEntries,
-            [BFF_EFFECT_WORKER_ENTRY_NAME]: [
-                `${effectApiEntry}?${BFF_EFFECT_WORKER_RUNTIME_QUERY}`
-            ]
-        } : baseWorkerEntries;
-        environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
-            output: {
-                target: useCloudflareModuleWorker ? 'web' : 'web-worker',
-                ...useCloudflareModuleWorker ? {
-                    module: true
-                } : {}
-            },
-            source: {
-                entry: workerEntries
-            },
-            tools: {
-                htmlPlugin: false,
-                ...useCloudflareModuleWorker ? {
-                    bundlerChain: (chain)=>{
-                        applyCloudflareWorkerRspackConfig(chain, Object.keys(workerEntries));
-                        chain.output.module(true).library({
-                            type: 'module'
-                        }).publicPath('/').chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
-                        for (const condition of [
-                            'workerd',
-                            'worker',
-                            'webpack',
-                            isProd() ? 'production' : 'development',
-                            'import',
-                            'require',
-                            'module'
-                        ])chain.resolve.conditionNames.add(condition);
-                        applyCloudflareWorkerMfRuntimeBoundary(chain);
-                        if (tanstackRouterSsrServerFile) {
-                            chain.resolve.alias.set('@tanstack/router-core/ssr/server$', tanstackRouterSsrServerFile);
-                            chain.resolve.alias.set('@tanstack/router-core/ssr/server', tanstackRouterSsrServerFile);
-                        }
-                        if (runtimeRscWorkerFile) {
-                            chain.resolve.alias.set('@modern-js/runtime/rsc/server$', runtimeRscWorkerFile);
-                            chain.resolve.alias.set('@modern-js/runtime/rsc/server', runtimeRscWorkerFile);
-                        }
-                        if (renderRscWorkerFile) {
-                            chain.resolve.alias.set('@modern-js/render/rsc$', renderRscWorkerFile);
-                            chain.resolve.alias.set('@modern-js/render/rsc', renderRscWorkerFile);
-                            chain.resolve.alias.set('@modern-js/render/rsc-worker$', renderRscWorkerFile);
-                        }
-                        setAliasIfPresent(chain.resolve.alias, 'react$', reactFile);
-                        setAliasIfPresent(chain.resolve.alias, 'react/jsx-runtime$', reactJsxRuntimeFile);
-                        setAliasIfPresent(chain.resolve.alias, 'react/jsx-dev-runtime$', reactJsxDevRuntimeFile);
-                        setAliasIfPresent(chain.resolve.alias, 'react-dom$', reactDomFile);
-                        setAliasIfPresent(chain.resolve.alias, 'react-dom/server.edge$', reactDomServerEdgeFile);
-                        setAliasIfPresent(chain.resolve.alias, '@loadable/component$', loadableComponentFile);
-                        setAliasIfPresent(chain.resolve.alias, '@loadable/server$', loadableServerWorkerFile);
-                        setAliasIfPresent(chain.resolve.alias, 'fs/promises$', fsPromisesWorkerFile);
-                        setAliasIfPresent(chain.resolve.alias, 'node:fs/promises$', fsPromisesWorkerFile);
-                        setAliasIfPresent(chain.resolve.alias, 'path$', pathWorkerFile);
-                        setAliasIfPresent(chain.resolve.alias, 'node:path$', pathWorkerFile);
-                        chain.resolve.alias.set('react-server-dom-rspack/server.node$', 'react-server-dom-rspack/server.edge');
-                        chain.resolve.alias.set('react-server-dom-rspack/server.node', 'react-server-dom-rspack/server.edge');
-                        chain.resolve.alias.set('react-server-dom-rspack/client.node$', 'react-server-dom-rspack/client.edge');
-                        chain.resolve.alias.set('react-server-dom-rspack/client.node', 'react-server-dom-rspack/client.edge');
-                        chain.resolve.fallback.set('fs', false);
-                        chain.resolve.fallback.set('node:fs', false);
-                    }
-                } : {}
-            }
-        };
-    }
+    if (useWorkerTarget) environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
+        output: {
+            target: 'web-worker'
+        },
+        source: {
+            entry: serverEntries
+        },
+        tools: {
+            htmlPlugin: false
+        }
+    };
     return {
         environments,
         builderConfig: tempBuilderConfig
     };
 }
-export { applyCloudflareWorkerMfRuntimeBoundary, applyCloudflareWorkerRspackConfig, getBuilderEnvironments, getCloudflareWorkerRspackConfig };
+export { getBuilderEnvironments };

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

@@ -1,7 +1,7 @@
 import "node:module";
 import { createBuilder } from "@modern-js/builder";
 import { mergeRsbuildConfig } from "@rsbuild/core";
-import { builderPluginAdapterBasic, builderPluginAdapterHooks, builderPluginAdapterHtml, builderPluginAdapterLazyCompilation, builderPluginAdapterPrecompress, builderPluginAdapterSSR } from "../shared/builderPlugins/index.mjs";
+import { builderPluginAdapterBasic, builderPluginAdapterHooks, builderPluginAdapterHtml, builderPluginAdapterPrecompress, builderPluginAdapterSSR } from "../shared/builderPlugins/index.mjs";
 import { builderPluginAdapterCopy } from "./adapterCopy.mjs";
 import { createBuilderProviderConfig } from "./createBuilderProviderConfig.mjs";
 import { getBuilderEnvironments } from "./getBuilderEnvironments.mjs";
@@ -39,7 +39,6 @@ async function generateBuilder(options, bundlerType) {
 async function applyBuilderPlugins(builder, options) {
     builder.addPlugins([
         builderPluginAdapterBasic(options),
-        builderPluginAdapterLazyCompilation(options),
         builderPluginAdapterSSR(options),
         builderPluginAdapterHtml(options),
         builderPluginAdapterPrecompress(options),

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

@@ -1,23 +1,33 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { CssExtractRuntimePlugin } from "@modern-js/app-tools-extensions";
 import { SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled } from "@modern-js/builder";
-import { fs, isUseRsc, isUseSSRBundle } from "@modern-js/utils";
+import { fs, isUseRsc, isUseSSRBundle, logger } from "@modern-js/utils";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { getServerCombinedModuleFile } from "../../../plugins/analyze/utils.mjs";
-import { CssExtractRuntimePlugin, HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins/index.mjs";
+import { aggregateEagerRouteComponentFiles, planSSRLazyCompilation } from "../lazyCompilation.mjs";
 import * as __rspack_external_path from "path";
 const builderPluginAdapterSSR = (options)=>({
         name: 'builder-plugin-adapter-modern-ssr',
         setup (api) {
-            const { normalizedConfig, appContext } = options;
-            api.modifyRsbuildConfig((config)=>mergeRsbuildConfig(config, {
+            const { normalizedConfig, appContext, eagerRouteComponentFilesByEntry } = options;
+            api.modifyRsbuildConfig((config)=>{
+                const merged = mergeRsbuildConfig(config, {
                     html: {
                         inject: isStreamingSSR(normalizedConfig) ? 'head' : void 0
                     },
                     server: {
                         compress: isStreamingSSR(normalizedConfig) || isUseRsc(normalizedConfig) ? false : void 0
                     }
-                }));
+                });
+                const lazyCompilation = getSSRLazyCompilation(merged.dev?.lazyCompilation, normalizedConfig, appContext, eagerRouteComponentFilesByEntry);
+                if (void 0 !== lazyCompilation) merged.dev = {
+                    ...merged.dev,
+                    lazyCompilation
+                };
+                return merged;
+            });
             api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment })=>{
                 const builderConfig = environment.config;
                 const { normalizedConfig } = options;
@@ -53,6 +63,22 @@ const isStreamingSSR = (userConfig)=>{
     }
     return false;
 };
+function getSSRLazyCompilation(current, normalizedConfig, appContext, eagerRouteComponentFilesByEntry) {
+    if (!current || isUseRsc(normalizedConfig) || !isStreamingSSR(normalizedConfig)) return;
+    const plan = planSSRLazyCompilation(current, aggregateEagerRouteComponentFiles(eagerRouteComponentFilesByEntry));
+    if (!plan.apply) {
+        if (plan.unresolvedByEntry) warnUnresolvedRouteComponents(appContext.appDirectory, plan.unresolvedByEntry);
+        return;
+    }
+    return plan.lazyCompilation;
+}
+const warnedLazyApps = new Set();
+function warnUnresolvedRouteComponents(appDirectory, unresolvedByEntry) {
+    if (warnedLazyApps.has(appDirectory)) return;
+    warnedLazyApps.add(appDirectory);
+    const detail = Array.from(unresolvedByEntry).map(([entry, comps])=>`${entry}: ${comps.join(', ')}`).join('; ');
+    logger.warn(`[lazyCompilation] Skipped stream SSR route-eager optimization because some route components could not be resolved to a file (${detail}). Lazy compilation may break first-screen CSS/JS for these routes.`);
+}
 function applyAsyncChunkHtmlPlugin({ chain, modernConfig, HtmlBundlerPlugin }) {
     if (isStreamingSSR(modernConfig) || isUseRsc(modernConfig)) chain.plugin('html-async-chunk').use(HtmlAsyncChunkPlugin, [
         HtmlBundlerPlugin
@@ -100,10 +126,9 @@ function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
     });
 }
 async function applySSRLoaderEntry(chain, optinos, isServer) {
-    const { appContext, normalizedConfig } = optinos;
+    const { appContext } = optinos;
     const { internalDirectory } = appContext;
     const { entrypoints } = appContext;
-    const isRsc = isUseRsc(normalizedConfig);
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         const { entryName } = entrypoint;
         const serverLoadersFile = getServerCombinedModuleFile(internalDirectory, entryName);
@@ -111,7 +136,7 @@ async function applySSRLoaderEntry(chain, optinos, isServer) {
             await fs.access(serverLoadersFile, fs.constants.F_OK);
             chain.entry(`${entryName}-server-loaders`).add(serverLoadersFile);
         } catch (err) {}
-        else if (isRsc) chain.entry(`${entryName}-server-loaders`).add("data:text/javascript,export%20{};");
+        else if (isUseRsc(optinos.normalizedConfig)) chain.entry(`${entryName}-server-loaders`).add("data:text/javascript,export%20{};");
     }));
 }
 function applySSRDataLoader(chain, options) {
@@ -122,4 +147,4 @@ function applySSRDataLoader(chain, options) {
     const reg = new RegExp(`${absolutePath}.*\\.(loader|data|data.client)\\.[t|j]sx?$`);
     chain.module.rule('ssr-data-loader').test(reg).use('data-loader').loader(require.resolve('@modern-js/plugin-data-loader/loader')).end();
 }
-export { builderPluginAdapterSSR };
+export { builderPluginAdapterSSR, getSSRLazyCompilation };

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

@@ -1,7 +1,6 @@
 import "node:module";
 export * from "./adapterBasic.mjs";
 export * from "./adapterHtml.mjs";
-export * from "./adapterLazyCompilation.mjs";
 export * from "./adapterPrecompress.mjs";
 export * from "./adapterSSR.mjs";
 export * from "./builderHooks.mjs";

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

@@ -1,5 +1,4 @@
 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

@@ -12,7 +12,7 @@ function aggregateEagerRouteComponentFiles(byEntry) {
         unresolvedByEntry
     };
 }
-function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
+function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
     const userTestFn = 'function' == typeof userTest ? userTest : userTest instanceof RegExp ? (m)=>userTest.test(m.resource || '') : ()=>true;
     return (m)=>{
         const resource = m.resource;
@@ -21,7 +21,7 @@ function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
-function planRouteEagerLazyCompilation(current, info) {
+function planSSRLazyCompilation(current, info) {
     if (!current) return {
         apply: false
     };
@@ -38,8 +38,8 @@ function planRouteEagerLazyCompilation(current, info) {
         apply: true,
         lazyCompilation: {
             ...base,
-            test: buildRouteEagerLazyCompilationTest(info.files, userTest)
+            test: buildSSRLazyCompilationTest(info.files, userTest)
         }
     };
 }
-export { aggregateEagerRouteComponentFiles, buildRouteEagerLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planRouteEagerLazyCompilation };
+export { aggregateEagerRouteComponentFiles, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };

package/dist/esm-node/bundleDocs.mjs

@@ -22,7 +22,7 @@ function bundleDocs({ source, target, indexFile = DEFAULT_INDEX_FILE, excludedDi
         withFileTypes: true
     })){
         if (!entry.isFile()) continue;
-        const from = node_path.join(entry.parentPath ?? entry.path, entry.name);
+        const from = node_path.join(entry.parentPath, entry.name);
         const rel = node_path.relative(source, from);
         if (!isBundled(rel)) continue;
         const to = node_path.join(target, rel);

package/dist/esm-node/index.mjs

@@ -1,5 +1,6 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { createCloudflareBuilderPlugin } from "@modern-js/app-tools-extensions/cloudflare-builder";
 import { castArray } from "@modern-js/builder";
 import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
 import { createAsyncHook } from "@modern-js/plugin";
@@ -15,7 +16,6 @@ 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";
@@ -31,8 +31,8 @@ const appTools = ()=>({
             analyze(),
             serverBuild(),
             backendFederationBuild(),
-            ultramodernReleaseEnvelope(),
-            deploy()
+            deploy(),
+            createCloudflareBuilderPlugin()
         ],
         post: [
             '@modern-js/plugin-initialize',

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

@@ -1,5 +1,5 @@
 import "node:module";
-import { ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, fs, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
+import { MAIN_ENTRY_NAME, ROUTE_SPEC_FILE, SERVER_BUNDLE_DIRECTORY, SERVER_WORKER_BUNDLE_DIRECTORY, fs, getEntryOptions, isPlainObject, removeLeadingSlash, removeTailSlash, urlJoin } from "@modern-js/utils";
 import path from "path";
 import { isMainEntry } from "../../utils/routes.mjs";
 import { walkDirectory } from "./utils.mjs";

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

@@ -11,23 +11,15 @@ const isDefaultExportFunction = (file)=>{
         plugins: [
             'jsx',
             "typescript",
-            'classProperties',
-            'dynamicImport',
             'exportDefaultFrom',
-            'exportNamespaceFrom',
             'decorators-legacy',
             'functionBind',
-            'classPrivateMethods',
             [
                 'pipelineOperator',
                 {
                     proposal: 'fsharp'
                 }
-            ],
-            'optionalChaining',
-            'optionalCatchBinding',
-            'objectRestSpread',
-            'numericSeparator'
+            ]
         ]
     });
     let isExportFunction = false;

package/dist/esm-node/plugins/backend-federation/codegen.mjs

@@ -99,7 +99,7 @@ module.exports = { __modernjsBackendFederation, get, init };
     if (!output) throw new Error('[backend-federation-build] CommonJS backend federation container emitted no output.');
     return output.text;
 };
-const createBackendManifest = (workspaceRoot, distDirectory, app)=>{
+const createBackendManifest = (workspaceRoot, distDirectory, app, entryIntegrity)=>{
     const sourceModule = `${app.directory}/api/effect-api.ts`;
     const publicPath = createPublicPath(app.containerEntry, app.port);
     const manifest = {
@@ -130,6 +130,7 @@ const createBackendManifest = (workspaceRoot, distDirectory, app)=>{
             ssrPublicPath: publicPath
         },
         entry: {
+            ...entryIntegrity,
             file: BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
             path: normalizeRelativePath(node_path.relative(workspaceRoot, node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE))),
             type: app.remoteType,

package/dist/esm-node/plugins/backend-federation/config.mjs

@@ -2,8 +2,8 @@ import "node:module";
 import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import node_path from "node:path";
+import { resolveUltramodernSourceRevision } from "@modern-js/app-tools-extensions/release-identity";
 import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, deliveryUnitContractBlock, isUltramodernBuildArtifact, validateDeliveryUnitRecord, validateUltramodernBuildArtifact } from "@modern-js/utils/universal";
-import { resolveUltramodernSourceRevision } from "../../ultramodern-release-identity.mjs";
 const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
 const normalizeRelativePath = (value)=>value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
 const isRecord = (value)=>'object' == typeof value && null !== value;

package/dist/esm-node/plugins/backend-federation/emit.mjs

@@ -2,8 +2,9 @@ import "node:module";
 import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import node_path from "node:path";
+import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensions/release-identity";
+import { createBackendFederationEntryIntegrity } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
 import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, stampUltramodernBuildArtifactIdentity } from "@modern-js/utils/universal";
-import { resolveUltramodernReleaseIdentity } from "../../ultramodern-release-identity.mjs";
 import { createBackendManifest, createBackendRemoteEntrySource } from "./codegen.mjs";
 import { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, readBuildIdentity, resolveWorkspaceSourceRevision } from "./config.mjs";
 const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
@@ -68,11 +69,12 @@ const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
     const manifestPath = node_path.join(distDirectory, BACKEND_FEDERATION_MANIFEST_FILE);
     const entryPath = node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
     const deliveryUnitArtifactPath = stampedBuildArtifact ? node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE) : void 0;
+    const entrySource = await createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath);
     await promises.mkdir(distDirectory, {
         recursive: true
     });
-    await promises.writeFile(entryPath, await createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath));
-    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp), null, 2)}\n`);
+    await promises.writeFile(entryPath, entrySource);
+    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp, createBackendFederationEntryIntegrity(entrySource)), null, 2)}\n`);
     if (stampedBuildArtifact && deliveryUnitArtifactPath) await promises.writeFile(deliveryUnitArtifactPath, `${JSON.stringify(stampedBuildArtifact, null, 2)}\n`);
     return {
         appId: resolvedApp.id,

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

@@ -1,6 +1,6 @@
 import "node:module";
+import { createCloudflarePreset } from "@modern-js/app-tools-extensions/cloudflare";
 import { provider } from "std-env";
-import { createCloudflarePreset } from "./platforms/cloudflare/index.mjs";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";