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

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-worker-loadable-server.mjs

@@ -0,0 +1,185 @@
+import loadableComponent from '@loadable/component';
+import React from 'react';
+const internals = loadableComponent?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED || {};
+const LoadableContext = internals.Context || React.createContext(null);
+const getRequiredChunkKey = internals.getRequiredChunkKey || ((namespace)=>`${namespace}__LOADABLE_REQUIRED_CHUNKS__`);
+const scriptExtensions = new Set([
+    '.js',
+    '.mjs'
+]);
+const styleExtensions = new Set([
+    '.css'
+]);
+function uniqByUrl(assets) {
+    const seen = new Set();
+    return assets.filter((asset)=>{
+        if (seen.has(asset.url)) return false;
+        seen.add(asset.url);
+        return true;
+    });
+}
+function extname(filePath) {
+    const basename = String(filePath).split('/').pop() || '';
+    const index = basename.lastIndexOf('.');
+    return index > 0 ? basename.slice(index) : '';
+}
+function joinUrl(publicPath, filename) {
+    const base = publicPath || '/';
+    return `${base.replace(/\/+$/u, '')}/${String(filename).replace(/^\/+/u, '')}`;
+}
+function extraPropsToString(extraProps = {}) {
+    return Object.entries(extraProps).filter(([, value])=>void 0 !== value && false !== value).map(([key, value])=>true === value ? ` ${key}` : ` ${key}="${value}"`).join('');
+}
+function assetScriptType(filename) {
+    const extension = extname(filename);
+    if (scriptExtensions.has(extension)) return "script";
+    if (styleExtensions.has(extension)) return 'style';
+}
+function getAssetName(asset) {
+    return 'object' == typeof asset && asset?.name ? asset.name : asset;
+}
+function getAssetIntegrity(asset) {
+    return 'object' == typeof asset && asset?.integrity ? asset.integrity : null;
+}
+function getChunkGroupAssets(chunkGroup) {
+    const assets = chunkGroup?.assets;
+    if (Array.isArray(assets)) return assets;
+    if (assets && 'object' == typeof assets) return [
+        ...assets.js || [],
+        ...assets.css || []
+    ];
+    return [];
+}
+function getChunkGroupChildAssets(chunkGroup, type) {
+    const childAssets = chunkGroup?.childAssets?.[type];
+    return Array.isArray(childAssets) ? childAssets : [];
+}
+function chunkIncludesJs(chunkInfo) {
+    return (chunkInfo?.files || []).some((file)=>scriptExtensions.has(extname(file)));
+}
+export function ChunkExtractorManager({ extractor, children }) {
+    return React.createElement(LoadableContext.Provider, {
+        value: extractor
+    }, children);
+}
+export class ChunkExtractor {
+    constructor({ stats, entrypoints = [
+        'main'
+    ], namespace = '', outputPath = '/', publicPath } = {}){
+        this.namespace = namespace;
+        this.stats = stats || {};
+        this.publicPath = publicPath || this.stats.publicPath || '/';
+        this.outputPath = outputPath || this.stats.outputPath || '/';
+        this.entrypoints = Array.isArray(entrypoints) ? entrypoints : [
+            entrypoints
+        ];
+        this.chunks = [];
+    }
+    addChunk(chunk) {
+        if (!this.chunks.includes(chunk)) this.chunks.push(chunk);
+    }
+    collectChunks(app) {
+        return React.createElement(ChunkExtractorManager, {
+            extractor: this
+        }, app);
+    }
+    getChunkGroup(chunk) {
+        return this.stats.namedChunkGroups?.[chunk] || {
+            assets: [],
+            childAssets: {},
+            chunks: []
+        };
+    }
+    getChunkInfo(chunkId) {
+        return (this.stats.chunks || []).find((chunk)=>chunk.id === chunkId);
+    }
+    resolvePublicUrl(filename) {
+        return joinUrl(this.publicPath, filename);
+    }
+    createChunkAsset({ filename, chunk, type, linkType }) {
+        const resolvedFilename = getAssetName(filename);
+        const scriptType = assetScriptType(resolvedFilename);
+        if (!scriptType) return;
+        return {
+            filename: resolvedFilename,
+            integrity: getAssetIntegrity(filename),
+            scriptType,
+            chunk,
+            url: this.resolvePublicUrl(resolvedFilename),
+            path: String(resolvedFilename).replace(/^\/+/u, ''),
+            type,
+            linkType
+        };
+    }
+    getChunkAssets(chunks) {
+        const one = (chunk)=>getChunkGroupAssets(this.getChunkGroup(chunk)).map((filename)=>this.createChunkAsset({
+                    filename,
+                    chunk,
+                    type: 'mainAsset',
+                    linkType: 'preload'
+                })).filter(Boolean);
+        return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+    }
+    getChunkChildAssets(chunks, type) {
+        const one = (chunk)=>getChunkGroupChildAssets(this.getChunkGroup(chunk), type).map((filename)=>this.createChunkAsset({
+                    filename,
+                    chunk,
+                    type: 'childAsset',
+                    linkType: type
+                })).filter(Boolean);
+        return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+    }
+    getChunkDependencies(chunks) {
+        const one = (chunk)=>(this.getChunkGroup(chunk).chunks || []).filter((chunkId)=>chunkIncludesJs(this.getChunkInfo(chunkId)));
+        return Array.isArray(chunks) ? [
+            ...new Set(chunks.flatMap(one))
+        ] : one(chunks);
+    }
+    getRequiredChunksScriptContent() {
+        return JSON.stringify(this.getChunkDependencies(this.chunks));
+    }
+    getRequiredChunksNamesScriptContent() {
+        return JSON.stringify({
+            namedChunks: this.chunks
+        });
+    }
+    getRequiredChunksScriptTag(extraProps = {}) {
+        const id = getRequiredChunkKey(this.namespace);
+        const props = `type="application/json"${extraPropsToString(extraProps)}`;
+        return [
+            `<script id="${id}" ${props}>${this.getRequiredChunksScriptContent()}</script>`,
+            `<script id="${id}_ext" ${props}>${this.getRequiredChunksNamesScriptContent()}</script>`
+        ].join('');
+    }
+    getMainAssets(scriptType) {
+        const assets = this.getChunkAssets([
+            ...this.entrypoints,
+            ...this.chunks
+        ]);
+        return scriptType ? assets.filter((asset)=>asset.scriptType === scriptType) : assets;
+    }
+    getScriptTags(extraProps = {}) {
+        const scripts = this.getMainAssets("script").map((asset)=>`<script async data-chunk="${asset.chunk}" src="${asset.url}"${extraPropsToString(extraProps)}></script>`);
+        return [
+            this.getRequiredChunksScriptTag(extraProps),
+            ...scripts
+        ].join('');
+    }
+    getStyleTags(extraProps = {}) {
+        return this.getMainAssets('style').map((asset)=>`<link data-chunk="${asset.chunk}" rel="stylesheet" href="${asset.url}"${extraPropsToString(extraProps)}>`).join('');
+    }
+    getLinkTags(extraProps = {}) {
+        const assets = [
+            ...this.getMainAssets(),
+            ...this.getChunkChildAssets([
+                ...this.entrypoints,
+                ...this.chunks
+            ], 'preload'),
+            ...this.getChunkChildAssets([
+                ...this.entrypoints,
+                ...this.chunks
+            ], 'prefetch')
+        ];
+        return uniqByUrl(assets).map((asset)=>`<link data-chunk="${asset.chunk}" rel="${asset.linkType}" as="${asset.scriptType}" href="${asset.url}"${extraPropsToString(extraProps)}>`).join('');
+    }
+}

package/dist/cjs/plugins/deploy/platforms/templates/cloudflare-worker-path.mjs

@@ -0,0 +1,59 @@
+const trimSlashes = (value)=>String(value).replace(/^\/+|\/+$/gu, '');
+const normalizeSeparators = (value)=>String(value).replace(/\\+/gu, '/');
+export const sep = '/';
+export const delimiter = ':';
+export function isAbsolute(filePath) {
+    return normalizeSeparators(filePath).startsWith('/');
+}
+export function normalize(filePath) {
+    const normalized = normalizeSeparators(filePath);
+    const absolute = isAbsolute(normalized);
+    const parts = [];
+    for (const part of normalized.split('/'))if (part && '.' !== part) {
+        if ('..' === part) {
+            if (parts.length > 0 && '..' !== parts[parts.length - 1]) parts.pop();
+            else if (!absolute) parts.push(part);
+            continue;
+        }
+        parts.push(part);
+    }
+    const joined = parts.join('/');
+    if (absolute) return joined ? `/${joined}` : '/';
+    return joined || '.';
+}
+export function join(...segments) {
+    const joined = segments.map(normalizeSeparators).filter(Boolean).map((segment, index)=>0 === index ? segment : trimSlashes(segment)).filter(Boolean).join('/');
+    return joined ? normalize(joined) : '.';
+}
+export function resolve(...segments) {
+    const joined = join(...segments);
+    return joined.startsWith('/') ? joined : `/${joined}`;
+}
+export function dirname(filePath) {
+    const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+    const index = normalized.lastIndexOf('/');
+    if (index <= 0) return '/';
+    return normalized.slice(0, index);
+}
+export function basename(filePath, suffix = '') {
+    const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+    const base = normalized.slice(normalized.lastIndexOf('/') + 1);
+    return suffix && base.endsWith(suffix) ? base.slice(0, -suffix.length) : base;
+}
+export function extname(filePath) {
+    const base = basename(filePath);
+    const index = base.lastIndexOf('.');
+    if (index <= 0) return '';
+    return base.slice(index);
+}
+export default {
+    basename,
+    delimiter,
+    dirname,
+    extname,
+    isAbsolute,
+    join,
+    normalize,
+    resolve,
+    sep
+};

package/dist/cjs/rsbuild.js

@@ -42,9 +42,11 @@ var __webpack_exports__ = {};
         resolveModernRsbuildConfig: ()=>resolveModernRsbuildConfig
     });
     const builder_namespaceObject = require("@modern-js/builder");
+    const utils_namespaceObject = require("@modern-js/utils");
     const index_js_namespaceObject = require("./builder/shared/builderPlugins/index.js");
     const external_constants_js_namespaceObject = require("./constants.js");
     const getConfigFile_js_namespaceObject = require("./utils/getConfigFile.js");
+    const loadPlugins_js_namespaceObject = require("./utils/loadPlugins.js");
     const MODERN_META_NAME = 'modern-js';
     const { createConfigOptions } = __webpack_require__("@modern-js/plugin/cli");
     async function resolveModernRsbuildConfig(options) {
@@ -55,6 +57,7 @@ var __webpack_exports__ = {};
             command: options.command,
             cwd,
             configFile,
+            internalPlugins: await (0, loadPlugins_js_namespaceObject.loadInternalPlugins)(cwd, utils_namespaceObject.INTERNAL_RUNTIME_PLUGINS),
             metaName,
             modifyModernConfig: options.modifyModernConfig
         });

package/dist/esm/baseline.mjs

@@ -1,4 +1,33 @@
+import { createRequire } from "node:module";
+import node_path from "node:path";
 import { mergeConfig } from "@modern-js/plugin/cli";
+const resolveReactRouterPackageDir = ()=>{
+    const localRequire = createRequire(node_path.join(process.cwd(), 'package.json'));
+    try {
+        const reactRouterDomPackageJson = localRequire.resolve('react-router-dom/package.json', {
+            paths: [
+                process.cwd()
+            ]
+        });
+        const reactRouterPackageJson = localRequire.resolve('react-router/package.json', {
+            paths: [
+                node_path.dirname(reactRouterDomPackageJson)
+            ]
+        });
+        return node_path.dirname(reactRouterPackageJson);
+    } catch  {
+        return;
+    }
+};
+const setReactRouterBridgeSafeAliases = (chain)=>{
+    const reactRouterPackageDir = resolveReactRouterPackageDir();
+    if (!reactRouterPackageDir) return;
+    const productionEntry = node_path.join(reactRouterPackageDir, 'dist/production/index.mjs');
+    const developmentEntry = node_path.join(reactRouterPackageDir, 'dist/development/index.mjs');
+    chain.resolve.alias.set('react-router$', productionEntry);
+    chain.resolve.alias.set('react-router/dist/production/index.js', productionEntry);
+    chain.resolve.alias.set('react-router/dist/development/index.js', developmentEntry);
+};
 const createAppBaselineConfig = (options = {})=>{
     const { appId = 'app', enableBffRequestId = true, enableTelemetry = true, enableTelemetryExporters = true, otlpEndpoint = process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs', victoriaMetricsEndpoint = process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus', telemetryFailLoudStartup = true, enableModuleFederationSSR = true } = options;
     const server = {};
@@ -32,7 +61,10 @@ const createAppBaselineConfig = (options = {})=>{
                 disableClientServer: true
             }
         },
-        server
+        server,
+        tools: {
+            bundlerChain: setReactRouterBridgeSafeAliases
+        }
     };
     if (enableBffRequestId) baselineConfig.bff = {
         requestId: appId

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

@@ -1,5 +1,69 @@
+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";
+const BFF_EFFECT_WORKER_ENTRY_NAME = '__modern_bff_effect';
+const BFF_EFFECT_WORKER_RUNTIME_QUERY = 'modern-bff-runtime';
+const JS_OR_TS_EXTS = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs'
+];
+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 resolvePackageEntry(packageName, paths) {
+    try {
+        return node_fs.realpathSync(require.resolve(packageName, {
+            paths
+        }));
+    } catch  {
+        return;
+    }
+}
+function resolvePackageFile(packageName, filePath, paths) {
+    try {
+        return node_fs.realpathSync(require.resolve(`${packageName}/${filePath}`, {
+            paths
+        }));
+    } catch  {
+        const packageEntry = resolvePackageEntry(packageName, paths);
+        if (!packageEntry) return;
+        const packageRoot = findPackageRoot(packageEntry, packageName);
+        const packageFile = packageRoot ? node_path.join(packageRoot, filePath) : void 0;
+        return packageFile && node_fs.existsSync(packageFile) ? node_fs.realpathSync(packageFile) : void 0;
+    }
+}
+function findPackageRoot(entryFile, packageName) {
+    let directory = node_path.dirname(entryFile);
+    while(directory !== node_path.dirname(directory)){
+        const packageJsonPath = node_path.join(directory, 'package.json');
+        try {
+            const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf-8'));
+            if (packageJson.name === packageName) return directory;
+        } catch  {}
+        directory = node_path.dirname(directory);
+    }
+}
+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 getEffectBffEntry(normalizedConfig, appContext) {
+    if (!normalizedConfig.bff || 'hono' === normalizedConfig.bff.runtimeFramework) return;
+    const configuredEntry = normalizedConfig.bff.effect?.entry;
+    const entryWithoutExtension = configuredEntry ? node_path.isAbsolute(configuredEntry) ? configuredEntry : node_path.resolve(appContext.appDirectory, configuredEntry) : node_path.resolve(appContext.apiDirectory, 'effect', 'index');
+    return findExistingFile(JS_OR_TS_EXTS.map((extension)=>`${entryWithoutExtension}${extension}`));
+}
+function isCloudflareWorkerDeploy(normalizedConfig) {
+    return normalizedConfig.deploy?.target === 'cloudflare' || 'cloudflare' === process.env.MODERNJS_DEPLOY;
+}
 function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig) {
     const entries = {};
     const { entrypoints = [], checkedEntries } = appContext;
@@ -16,6 +80,11 @@ 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: {
@@ -40,14 +109,117 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
         }
     };
     const useWorkerTarget = isServiceWorker(normalizedConfig);
-    if (useWorkerTarget) environments[SERVICE_WORKER_ENVIRONMENT_NAME] = {
-        output: {
-            target: 'web-worker'
-        },
-        source: {
-            entry: serverEntries
-        }
-    };
+    if (useWorkerTarget) {
+        const useCloudflareModuleWorker = isCloudflareWorkerDeploy(normalizedConfig);
+        const effectBffEntry = 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 = effectBffEntry ? {
+            ...baseWorkerEntries,
+            [BFF_EFFECT_WORKER_ENTRY_NAME]: [
+                `${effectBffEntry}?${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)=>{
+                        chain.merge({
+                            experiments: {
+                                outputModule: true
+                            }
+                        });
+                        chain.output.module(true).library({
+                            type: 'module'
+                        }).chunkFormat('module').chunkLoading('import').workerChunkLoading('import');
+                        chain.target('webworker');
+                        chain.plugins.delete('plugin-module-federation');
+                        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('async_hooks', false);
+                        chain.resolve.fallback.set('node:async_hooks', false);
+                        chain.resolve.fallback.set('fs', false);
+                        chain.resolve.fallback.set('node:fs', false);
+                    }
+                } : {}
+            }
+        };
+    }
     return {
         environments,
         builderConfig: tempBuilderConfig

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

@@ -5,8 +5,11 @@ const builderPluginAdapterBasic = (options)=>({
         setup (api) {
             api.modifyBundlerChain((chain, { target, CHAIN_ID, environment })=>{
                 const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
-                if ('node' === target || isServiceWorker) applyNodeCompat(isServiceWorker, chain);
-                if ('web' === target) {
+                const isWebTargetServiceWorker = isServiceWorker && 'web' === target;
+                if ('node' === target || isServiceWorker) applyNodeCompat(isServiceWorker, chain, {
+                    includeNodeExtensions: !isWebTargetServiceWorker
+                });
+                if ('web' === target && !isServiceWorker) {
                     const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
                     const depExt = 'mjs';
                     chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
@@ -22,8 +25,40 @@ const builderPluginAdapterBasic = (options)=>({
             });
             api.modifyRspackConfig((config, { target, environment })=>{
                 const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+                const isWebTargetServiceWorker = isServiceWorker && 'web' === target;
                 if ('node' === target || isServiceWorker) {
-                    const extensionAlias = {
+                    const extensionAlias = isWebTargetServiceWorker ? {
+                        '.js': [
+                            '.worker.js',
+                            '.server.js',
+                            '.js'
+                        ],
+                        '.jsx': [
+                            '.worker.jsx',
+                            '.server.jsx',
+                            '.jsx'
+                        ],
+                        '.ts': [
+                            '.worker.ts',
+                            '.server.ts',
+                            '.ts'
+                        ],
+                        '.tsx': [
+                            '.worker.tsx',
+                            '.server.tsx',
+                            '.tsx'
+                        ],
+                        '.mjs': [
+                            '.worker.mjs',
+                            '.server.mjs',
+                            '.mjs'
+                        ],
+                        '.json': [
+                            '.worker.json',
+                            '.server.json',
+                            '.json'
+                        ]
+                    } : {
                         '.js': [
                             '.node.js',
                             '.server.js',
@@ -64,7 +99,8 @@ const builderPluginAdapterBasic = (options)=>({
             });
         }
     });
-function applyNodeCompat(isServiceWorker, chain) {
+function applyNodeCompat(isServiceWorker, chain, options = {}) {
+    const { includeNodeExtensions = true } = options;
     const nodeExts = [
         '.node.js',
         '.node.jsx',
@@ -83,7 +119,7 @@ function applyNodeCompat(isServiceWorker, chain) {
         '.worker.ts',
         '.worker.tsx'
     ];
-    for (const ext of nodeExts)chain.resolve.extensions.prepend(ext);
+    if (includeNodeExtensions) for (const ext of nodeExts)chain.resolve.extensions.prepend(ext);
     if (isServiceWorker) for (const ext of webWorkerExts)chain.resolve.extensions.prepend(ext);
 }
 export { builderPluginAdapterBasic };

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

@@ -94,9 +94,10 @@ function applyFilterEntriesBySSRConfig({ isProd, chain, appNormalizedConfig }) {
     });
 }
 async function applySSRLoaderEntry(chain, optinos, isServer) {
-    const { appContext } = optinos;
+    const { appContext, normalizedConfig } = 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);
@@ -104,6 +105,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{};");
     }));
 }
 function applySSRDataLoader(chain, options) {

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

@@ -1,4 +1,5 @@
 import { provider } from "std-env";
+import { createCloudflarePreset } from "./platforms/cloudflare.mjs";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";
@@ -8,14 +9,18 @@ const deployPresets = {
     node: createNodePreset,
     vercel: createVercelPreset,
     netlify: createNetlifyPreset,
-    ghPages: createGhPagesPreset
+    ghPages: createGhPagesPreset,
+    cloudflare: createCloudflarePreset
 };
+const getSupportedDeployTargets = ()=>Object.keys(deployPresets);
+const isDeployTarget = (target)=>Object.prototype.hasOwnProperty.call(deployPresets, target);
+const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = provider)=>modernConfig.deploy?.target || envDeployTarget || detectedProvider || 'node';
 async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory, metaName);
     const needModernServer = useSSR || useAPI || useWebServer;
+    if (!isDeployTarget(deployTarget)) throw new Error(`Unknown deploy target: '${deployTarget}'. deploy.target or MODERNJS_DEPLOY should be one of: ${getSupportedDeployTargets().join(', ')}.`);
     const createPreset = deployPresets[deployTarget];
-    if (!createPreset) throw new Error(`Unknown deploy target: '${deployTarget}'. MODERNJS_DEPLOY should be 'node', 'vercel', or 'netlify'.`);
     return createPreset({
         appContext,
         modernConfig,
@@ -26,12 +31,12 @@ async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
 const deploy = ()=>({
         name: '@modern-js/plugin-deploy',
         setup: (api)=>{
-            const deployTarget = process.env.MODERNJS_DEPLOY || provider || 'node';
             api.deploy(async ()=>{
                 const appContext = api.getAppContext();
                 const { metaName } = appContext;
-                if ('modern-js' !== metaName && !process.env.MODERNJS_DEPLOY) return;
                 const modernConfig = api.getNormalizedConfig();
+                const deployTarget = resolveDeployTarget(modernConfig);
+                if ('modern-js' !== metaName && !modernConfig.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
                 const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget, api);
                 deployPreset?.prepare && await deployPreset?.prepare();
                 deployPreset?.writeOutput && await deployPreset?.writeOutput();
@@ -41,3 +46,4 @@ const deploy = ()=>({
         }
     });
 export default deploy;
+export { getSupportedDeployTargets, resolveDeployTarget };