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

package/dist/cjs/plugins/deploy/platforms/templates/vercel-entry.mjs

@@ -2,78 +2,57 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createProdServer } from '@modern-js/prod-server';
-
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
 p_genPluginImportsCode;
-
-if (!process.env.NODE_ENV) {
-  process.env.NODE_ENV = 'production';
-}
-
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
 let requestHandler = null;
 let handlerCreationPromise = null;
-
 async function loadRoutes(routeFilepath) {
-  try {
-    await fs.access(routeFilepath);
-    const content = await fs.readFile(routeFilepath, 'utf-8');
-    const routeSpec = JSON.parse(content);
-    return routeSpec.routes || [];
-  } catch (error) {
-    console.warn(
-      'route.json not found or invalid, continuing with empty routes.',
-    );
-    return [];
-  }
+    try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, 'utf-8');
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+    } catch (error) {
+        console.warn('route.json not found or invalid, continuing with empty routes.');
+        return [];
+    }
 }
-
 async function initServer() {
-  const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
-  const routes = await loadRoutes(routeFilepath);
-
-  const dynamicProdOptions = p_dynamicProdOptions;
-
-  const prodServerOptions = {
-    pwd: __dirname,
-    routes,
-    disableCustomHook: true,
-    appContext: {
-      sharedDirectory: p_sharedDirectory,
-      apiDirectory: p_apiDirectory,
-      lambdaDirectory: p_lambdaDirectory,
-    },
-    plugins: p_plugins,
-    serverConfigPath: p_serverDirectory,
-    ...dynamicProdOptions,
-  };
-  const app = await createProdServer(prodServerOptions);
-
-  return app.getRequestListener();
+    const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+    const routes = await loadRoutes(routeFilepath);
+    const dynamicProdOptions = p_dynamicProdOptions;
+    const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+            sharedDirectory: p_sharedDirectory,
+            apiDirectory: p_apiDirectory,
+            lambdaDirectory: p_lambdaDirectory
+        },
+        plugins: p_plugins,
+        serverConfigPath: p_serverDirectory,
+        ...dynamicProdOptions
+    };
+    const app = await createProdServer(prodServerOptions);
+    return app.getRequestListener();
 }
-
 async function createHandler() {
-  if (!handlerCreationPromise) {
-    handlerCreationPromise = (async () => {
-      try {
-        requestHandler = await initServer();
-      } catch (error) {
-        console.error('Error creating server:', error);
-        process.exit(1);
-      }
+    if (!handlerCreationPromise) handlerCreationPromise = (async ()=>{
+        try {
+            requestHandler = await initServer();
+        } catch (error) {
+            console.error('Error creating server:', error);
+            process.exit(1);
+        }
     })();
-  }
-  await handlerCreationPromise;
-  return requestHandler;
+    await handlerCreationPromise;
+    return requestHandler;
 }
-
 createHandler();
-
-const handler = async (req, res) => {
-  if (!requestHandler) {
-    await createHandler();
-  }
-  return requestHandler(req, res);
+const handler = async (req, res)=>{
+    if (!requestHandler) await createHandler();
+    return requestHandler(req, res);
 };
-
 export default handler;

package/dist/cjs/plugins/ultramodernReleaseEnvelope.js

@@ -1,14 +1,5 @@
 "use strict";
 var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
 (()=>{
     __webpack_require__.d = (exports1, getters, values)=>{
         var define = (defs, kind)=>{
@@ -39,57 +30,10 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     default: ()=>ultramodernReleaseEnvelope
 });
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const framework_output_js_namespaceObject = require("../ultramodern-release-envelope/framework-output.js");
+const plugin_namespaceObject = require("@modern-js/app-tools-extensions/release-envelope/plugin");
 const index_js_namespaceObject = require("./deploy/index.js");
-const resolveActiveDeployTarget = (api)=>{
-    const { metaName } = api.getAppContext();
-    const config = api.getNormalizedConfig();
-    if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
-    return (0, index_js_namespaceObject.resolveDeployTarget)(config);
-};
-const ultramodernReleaseEnvelope = ()=>({
-        name: '@modern-js/ultramodern-release-envelope',
-        pre: [
-            '@modern-js/backend-federation-build',
-            '@modern-js/plugin-bff'
-        ],
-        setup (api) {
-            const emitBuildEnvelope = async (target)=>{
-                const { apiOnly, distDirectory } = api.getAppContext();
-                await (0, framework_output_js_namespaceObject.emitFrameworkMicroVerticalReleaseEnvelope)({
-                    apiOnly,
-                    distDirectory,
-                    target
-                });
-            };
-            api.onAfterBuild(async ()=>{
-                const configuredTarget = (0, index_js_namespaceObject.resolveDeployTarget)(api.getNormalizedConfig());
-                if ('node' !== configuredTarget && 'cloudflare' !== configuredTarget) return;
-                await emitBuildEnvelope(configuredTarget);
-            });
-            api.onBeforeDeploy(async ()=>{
-                const configuredTarget = resolveActiveDeployTarget(api);
-                if ('node' !== configuredTarget) return;
-                await emitBuildEnvelope(configuredTarget);
-                const { distDirectory } = api.getAppContext();
-                await (0, framework_output_js_namespaceObject.verifyBuildOutputReleaseEnvelope)(distDirectory, configuredTarget);
-            });
-            api.onAfterDeploy(async ()=>{
-                const configuredTarget = resolveActiveDeployTarget(api);
-                if ('node' !== configuredTarget) return;
-                const { appDirectory, distDirectory } = api.getAppContext();
-                const outputDirectory = external_node_path_default().join(appDirectory, '.output');
-                const releaseEnvelope = await (0, framework_output_js_namespaceObject.emitNodeStagedReleaseEnvelope)({
-                    distDirectory,
-                    outputDirectory
-                });
-                if (releaseEnvelope) await (0, framework_output_js_namespaceObject.verifyNodeReleaseEnvelopeStaging)({
-                    outputDirectory
-                });
-            });
-        }
+const ultramodernReleaseEnvelope = ()=>(0, plugin_namespaceObject.createUltramodernReleaseEnvelopePlugin)({
+        resolveDeployTarget: index_js_namespaceObject.resolveDeployTarget
     });
 exports["default"] = __webpack_exports__["default"];
 for(var __rspack_i in __webpack_exports__)if (-1 === [

package/dist/cjs/presetUltramodern.js

@@ -38,15 +38,18 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createPresetUltramodernConfig: ()=>createPresetUltramodernConfig,
-    presetUltramodern: ()=>presetUltramodern
+    presetUltramodern: ()=>presetUltramodern,
+    ultramodernReleaseEnvelopePlugin: ()=>ultramodernReleaseEnvelope_js_default()
 });
 const external_node_fs_namespaceObject = require("node:fs");
 var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const release_identity_namespaceObject = require("@modern-js/app-tools-extensions/release-identity");
 const cli_namespaceObject = require("@modern-js/plugin/cli");
 const core_namespaceObject = require("@rsbuild/core");
-const external_ultramodern_release_identity_js_namespaceObject = require("./ultramodern-release-identity.js");
+const ultramodernReleaseEnvelope_js_namespaceObject = require("./plugins/ultramodernReleaseEnvelope.js");
+var ultramodernReleaseEnvelope_js_default = /*#__PURE__*/ __webpack_require__.n(ultramodernReleaseEnvelope_js_namespaceObject);
 const DEFAULT_OTLP_ENDPOINT = 'http://127.0.0.1:4318/v1/logs';
 const DEFAULT_VICTORIA_METRICS_ENDPOINT = 'http://127.0.0.1:8428/api/v1/import/prometheus';
 const resolveReactRouterPackageDir = (appDirectory)=>{
@@ -81,7 +84,7 @@ const setReactRouterBridgeSafeAliases = (chain, { isProd })=>{
 const createPresetUltramodernConfig = (options = {})=>{
     const { appId = 'app', deliveryUnit, enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT, victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT, telemetryFailLoudStartup = false, enableModuleFederationSSR = true } = options;
     const server = {};
-    const releaseIdentity = deliveryUnit ? (0, external_ultramodern_release_identity_js_namespaceObject.resolveUltramodernReleaseIdentity)({
+    const releaseIdentity = deliveryUnit ? (0, release_identity_namespaceObject.resolveUltramodernReleaseIdentity)({
         generationBuildMarker: deliveryUnit.buildMarker,
         unitId: deliveryUnit.unitId
     }) : void 0;
@@ -116,17 +119,19 @@ const createPresetUltramodernConfig = (options = {})=>{
             precompress: true
         },
         server,
-        ...deliveryUnit ? {
-            source: {
+        source: {
+            reactCompiler: true,
+            ...deliveryUnit ? {
                 globalVars: {
                     ULTRAMODERN_BUILD_MARKER: releaseIdentity?.buildMarker,
                     ULTRAMODERN_RELEASE_VERSION: deliveryUnit.version,
                     ULTRAMODERN_SOURCE_REVISION: releaseIdentity?.sourceRevision
                 }
-            }
-        } : {},
+            } : {}
+        },
         tools: {
             bundlerChain: setReactRouterBridgeSafeAliases,
+            lightningcssLoader: true,
             ...bundledReleaseIdentity ? {
                 rspack: (config)=>{
                     config.plugins ??= [];
@@ -152,9 +157,11 @@ const presetUltramodern = (config, options = {})=>(0, cli_namespaceObject.mergeC
     ]);
 exports.createPresetUltramodernConfig = __webpack_exports__.createPresetUltramodernConfig;
 exports.presetUltramodern = __webpack_exports__.presetUltramodern;
+exports.ultramodernReleaseEnvelopePlugin = __webpack_exports__.ultramodernReleaseEnvelopePlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createPresetUltramodernConfig",
-    "presetUltramodern"
+    "presetUltramodern",
+    "ultramodernReleaseEnvelopePlugin"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/run/index.js

@@ -40,25 +40,25 @@ const loadPlugins_js_namespaceObject = require("../utils/loadPlugins.js");
 async function createRunOptions({ cwd, initialLog, metaName = 'modern-js', version, internalPlugins, configFile }) {
     const nodeVersion = process.versions.node;
     const versionArr = nodeVersion.split('.').map(Number);
-    if (versionArr[0] <= 16) console.warn(`
-  ${utils_namespaceObject.chalk.bgRed.white.bold(' ⚠️ CRITICAL NODE.JS VERSION ALERT ⚠️ ')}
+    if (versionArr[0] < 26 || 26 === versionArr[0] && versionArr[1] < 7) throw new Error(`
+  ${utils_namespaceObject.chalk.bgRed.white.bold(' UNSUPPORTED NODE.JS RUNTIME ')}
 
-  ${utils_namespaceObject.chalk.red.bold('Node.js 16 End-of-Life Notice:')}
-  ${utils_namespaceObject.chalk.red('- Security updates and support have ended for Node.js 16')}
+  ${utils_namespaceObject.chalk.red.bold(`UltraModern.js requires Node.js >=26.7.0; detected v${nodeVersion}.`)}
+  ${utils_namespaceObject.chalk.red('- Legacy Node runtimes and TypeScript transpiler fallbacks are unsupported.')}
 
   ${utils_namespaceObject.chalk.yellow('▸ Detected Runtime:')}  ${utils_namespaceObject.chalk.yellow.bold(`Node.js v${nodeVersion}`)}
-  ${utils_namespaceObject.chalk.green('▸ Required Minimum:')} ${utils_namespaceObject.chalk.green.bold('Node.js LTS (v18.x or higher)')}
-  ${utils_namespaceObject.chalk.green('▸ Recommended:')} ${utils_namespaceObject.chalk.green.bold('Node.js LTS (v22.x or higher)')}
+  ${utils_namespaceObject.chalk.green('▸ Required Minimum:')} ${utils_namespaceObject.chalk.green.bold('Node.js v26.7.0 or higher')}
+  ${utils_namespaceObject.chalk.green('▸ Pinned Runtime:')} ${utils_namespaceObject.chalk.green.bold('Node.js v26.7.0')}
 
   ${utils_namespaceObject.chalk.cyan('Immediate Action Required:')}
     ${utils_namespaceObject.chalk.gray('├──')} ${utils_namespaceObject.chalk.yellow('Recommended Upgrade')}
-       ${utils_namespaceObject.chalk.bold('nvm install 22 --lts && nvm use 22')}
+       ${utils_namespaceObject.chalk.bold('mise install && mise exec -- node --version')}
     ${utils_namespaceObject.chalk.gray('├──')} ${utils_namespaceObject.chalk.yellow('Manual Installation')}
-       ${utils_namespaceObject.chalk.underline('https://nodejs.org/download/release/lts-hydrogen/')}
+       ${utils_namespaceObject.chalk.underline('https://nodejs.org/download/release/v26.7.0/')}
      ${utils_namespaceObject.chalk.gray('└──')} ${utils_namespaceObject.chalk.yellow('Environment Verification')}
        ${utils_namespaceObject.chalk.bold('node -v && npm -v')}
 
-  ${utils_namespaceObject.chalk.hex('#AAAAAA').italic('[Security Advisory] Node.js 16 is no longer supported. Upgrade immediately for security and compatibility.')}
+  ${utils_namespaceObject.chalk.hex('#AAAAAA').italic('[Runtime Policy] Upgrade Node; UltraModern.js intentionally carries no legacy transpiler fallback.')}
       `);
     const command = process.argv[2];
     const cliParams = (0, utils_namespaceObject.minimist)(process.argv.slice(2));

package/dist/cjs/utils/env.js

@@ -37,7 +37,7 @@ function getAutoInjectEnv(appContext) {
     const envReg = new RegExp(`^${prefix}`);
     return Object.keys(process.env).reduce((prev, key)=>{
         const value = process.env[key];
-        if (envReg.test(key) && void 0 !== value) prev[`process.env.${key}`] = value;
+        if (envReg.test(key) && 'MODERN_MF_APP_SSR' !== key && void 0 !== value) prev[`process.env.${key}`] = value;
         return prev;
     }, {});
 }

package/dist/cjs/utils/register.js

@@ -91,12 +91,16 @@ const createRuntimePaths = ({ alias, paths, absoluteBaseUrl })=>{
 };
 const resolveTsRuntimeRegisterMode = ()=>{
     const hasNativeTypeScriptSupport = process.features?.typescript;
-    const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
-    const supportsNativeTypeScript = void 0 === hasNativeTypeScriptSupport ? nodeMajorVersion >= 22 : false !== hasNativeTypeScriptSupport;
+    const nodeVersion = process.versions.node.split('.').map(Number);
+    const supportsNativeTypeScript = (nodeVersion[0] > 26 || 26 === nodeVersion[0] && nodeVersion[1] >= 7) && [
+        true,
+        'strip'
+    ].includes(hasNativeTypeScriptSupport);
     if (supportsNativeTypeScript) return 'node-loader';
     return 'unsupported';
 };
 const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
+    if ('unsupported' === resolveTsRuntimeRegisterMode()) throw new Error(`UltraModern.js requires Node.js >=26.7.0 with native TypeScript support; detected v${process.versions.node}. Legacy TypeScript runtime transpilers are unsupported.`);
     const tsconfigPath = (0, utils_namespaceObject.resolveServerTsconfig)(appDir, options.tsconfigPath);
     const isTsProject = await utils_namespaceObject.fs.pathExists(tsconfigPath);
     if (!isTsProject) return;
@@ -111,7 +115,6 @@ const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
         paths,
         absoluteBaseUrl
     });
-    if ('unsupported' === registerMode) return;
     if ('node-loader' === registerMode) {
         const { registerPathsLoader } = await import("../esm/register-esm.js");
         await registerPathsLoader({

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

@@ -2,30 +2,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";
-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(__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, {
@@ -69,94 +45,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,
@@ -210,11 +98,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: {
@@ -239,122 +122,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/builder/generator/index.mjs

@@ -1,6 +1,6 @@
 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";
@@ -38,7 +38,6 @@ async function generateBuilder(options, bundlerType) {
 async function applyBuilderPlugins(builder, options) {
     builder.addPlugins([
         builderPluginAdapterBasic(options),
-        builderPluginAdapterLazyCompilation(options),
         builderPluginAdapterSSR(options),
         builderPluginAdapterHtml(options),
         builderPluginAdapterPrecompress(options),