@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.5 → 3.2.0-ultramodern.51

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

@@ -0,0 +1,258 @@
+const ASSETS_BINDING = 'ASSETS';
+const MODERN_WORKER_MANIFEST = p_workerManifest;
+const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
+const workerModulePromises = new Map();
+const CORS_HEADERS = {
+    'access-control-allow-headers': '*',
+    'access-control-allow-methods': 'GET, HEAD, OPTIONS',
+    'access-control-allow-origin': '*'
+};
+globalThis.__dirname ??= '/';
+globalThis.__filename ??= '/index.js';
+function withCorsHeaders(response) {
+    const headers = new Headers(response.headers);
+    for (const [name, value] of Object.entries(CORS_HEADERS))if (!headers.has(name)) headers.set(name, value);
+    return new Response(response.body, {
+        headers,
+        status: response.status,
+        statusText: response.statusText
+    });
+}
+function createCorsPreflightResponse(request) {
+    if ('OPTIONS' !== request.method) return null;
+    return new Response(null, {
+        headers: CORS_HEADERS,
+        status: 204
+    });
+}
+async function fetchAsset(request, env) {
+    const assets = env?.[ASSETS_BINDING];
+    if (!assets || 'function' != typeof assets.fetch) return null;
+    const response = await assets.fetch(request);
+    if (404 === response.status) return null;
+    return withCorsHeaders(response);
+}
+async function fetchAssetByPath(pathname, request, env) {
+    const url = new URL(request.url);
+    url.pathname = `/${pathname.replace(/^\/+/u, '')}`;
+    return fetchAsset(new Request(url, request), env);
+}
+async function fetchAssetByPathFollowingRedirects(pathname, request, env, visited = new Set()) {
+    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    if (visited.has(normalizedPathname)) return null;
+    visited.add(normalizedPathname);
+    const response = await fetchAssetByPath(normalizedPathname, request, env);
+    if (response && response.status >= 300 && response.status < 400 && response.headers.has('location')) {
+        const location = response.headers.get('location');
+        if (location) {
+            const nextUrl = new URL(location, request.url);
+            const currentUrl = new URL(request.url);
+            if (nextUrl.origin === currentUrl.origin) return fetchAssetByPathFollowingRedirects(nextUrl.pathname, request, env, visited);
+        }
+    }
+    return response;
+}
+async function readAssetText(pathname, request, env) {
+    const response = await fetchAssetByPathFollowingRedirects(pathname, request, env);
+    if (!response || !response.ok) return;
+    return response.text();
+}
+async function readAssetJson(pathname, request, env) {
+    const text = await readAssetText(pathname, request, env);
+    if (!text) return {};
+    return JSON.parse(text);
+}
+function normalizeRoutePath(pathname) {
+    if ('/' === pathname) return pathname;
+    return pathname.replace(/\/+$/u, '');
+}
+function routeMatches(route, pathname) {
+    if ('string' != typeof route.urlPath) return false;
+    const routePath = normalizeRoutePath(route.urlPath);
+    const requestPath = normalizeRoutePath(pathname);
+    return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
+}
+function findRoute(request) {
+    const { pathname } = new URL(request.url);
+    const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
+    return [
+        ...routes
+    ].sort((left, right)=>{
+        const leftLength = left.urlPath?.length || 0;
+        const rightLength = right.urlPath?.length || 0;
+        return rightLength - leftLength;
+    }).find((route)=>routeMatches(route, pathname));
+}
+async function fetchRouteHtml(route, request, env) {
+    if (!route?.entryPath) return null;
+    return fetchAssetByPath(route.entryPath, request, env);
+}
+function createNoopMonitors() {
+    const noop = ()=>{};
+    return {
+        debug: noop,
+        error: noop,
+        info: noop,
+        warn: noop
+    };
+}
+function createRequestHandlerOptions({ route, htmlTemplate, routeManifest, loadableStats }) {
+    const monitors = createNoopMonitors();
+    return {
+        resource: {
+            route,
+            routeManifest,
+            loadableStats,
+            htmlTemplate,
+            entryName: route.entryName
+        },
+        params: {},
+        loaderContext: {},
+        config: {},
+        locals: {},
+        staticGenerate: false,
+        monitors,
+        onError (error) {
+            monitors.error(error);
+        },
+        onTiming () {},
+        reporter: {
+            reportTiming: ()=>{}
+        }
+    };
+}
+async function getRequestHandlerOptions(route, request, env) {
+    const [htmlTemplate, routeManifest, loadableStats] = await Promise.all([
+        readAssetText(route.entryPath, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.routeManifest, request, env),
+        readAssetJson(MODERN_WORKER_MANIFEST.resources.loadableStats, request, env)
+    ]);
+    return createRequestHandlerOptions({
+        route,
+        htmlTemplate: htmlTemplate || '',
+        routeManifest,
+        loadableStats
+    });
+}
+async function loadWorkerModule(workerPath) {
+    const loader = WORKER_MODULE_LOADERS[workerPath];
+    if (!loader) return;
+    if (!workerModulePromises.has(workerPath)) workerModulePromises.set(workerPath, loader());
+    return workerModulePromises.get(workerPath);
+}
+function getFetchHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    return defaultExport && 'object' == typeof defaultExport && 'function' == typeof defaultExport.fetch && defaultExport.fetch.bind(defaultExport) || 'function' == typeof workerModule.fetch && workerModule.fetch;
+}
+async function getRequestHandler(workerModule) {
+    const defaultExport = workerModule.default;
+    const defaultRequestHandler = defaultExport && 'object' == typeof defaultExport && 'requestHandler' in defaultExport ? defaultExport.requestHandler : void 0;
+    return await workerModule.requestHandler || await defaultRequestHandler || ('function' == typeof defaultExport ? defaultExport : void 0);
+}
+async function dispatchRouteWorker(route, request, env, ctx) {
+    const workerPath = route.worker;
+    if (!workerPath) return new Response('Worker bundle not configured for SSR route', {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8'
+        }
+    });
+    const workerModule = await loadWorkerModule(workerPath);
+    if (!workerModule) return new Response(`Worker bundle not found: ${workerPath}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': workerPath
+        }
+    });
+    const fetchHandler = getFetchHandler(workerModule);
+    if (fetchHandler) return fetchHandler(request, env, ctx);
+    const requestHandler = await getRequestHandler(workerModule);
+    if ('function' == typeof requestHandler) {
+        const requestHandlerOptions = await getRequestHandlerOptions(route, request, env);
+        return requestHandler(request, requestHandlerOptions);
+    }
+    return new Response(`Worker bundle has no fetch or requestHandler export: ${workerPath}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-route-worker': workerPath
+        }
+    });
+}
+function matchesPrefix(pathname, prefix) {
+    if (!prefix || '/' === prefix) return true;
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    return pathname === normalized || pathname.startsWith(`${normalized}/`);
+}
+function createRequestForMountedPrefix(request, prefix) {
+    if (!prefix || '/' === prefix) return request;
+    const url = new URL(request.url);
+    const normalized = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+    if (!matchesPrefix(url.pathname, normalized)) return request;
+    const nextPath = url.pathname.slice(normalized.length) || '/';
+    url.pathname = nextPath.startsWith('/') ? nextPath : `/${nextPath}`;
+    return new Request(url, request);
+}
+function createEffectContext(originalRequest, mountedRequest, env) {
+    const url = new URL(originalRequest.url);
+    return {
+        request: mountedRequest,
+        env: env || {},
+        path: url.pathname,
+        method: originalRequest.method,
+        operationContext: {
+            request: mountedRequest,
+            env: env || {},
+            path: url.pathname,
+            method: originalRequest.method
+        }
+    };
+}
+async function dispatchBffRequest(request, env) {
+    const bff = MODERN_WORKER_MANIFEST.bff;
+    if (!bff?.worker || !matchesPrefix(new URL(request.url).pathname, bff.prefix)) return null;
+    const workerModule = await loadWorkerModule(bff.worker);
+    if (!workerModule) return new Response(`BFF worker bundle not found: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    const mountedRequest = createRequestForMountedPrefix(request, bff.prefix);
+    const effectContext = createEffectContext(request, mountedRequest, env);
+    const defaultExport = workerModule.default;
+    const runtime = defaultExport && 'object' == typeof defaultExport ? {
+        ...workerModule,
+        ...defaultExport
+    } : workerModule;
+    const directHandler = 'function' == typeof runtime.handler && runtime.handler || 'function' == typeof defaultExport && defaultExport;
+    const createdHandler = 'function' == typeof runtime.createHandler ? runtime.createHandler().handler : void 0;
+    const handler = directHandler || createdHandler;
+    if ('function' != typeof handler) return new Response(`BFF worker bundle has no handler export: ${bff.worker}`, {
+        status: 500,
+        headers: {
+            'content-type': 'text/plain; charset=utf-8',
+            'x-modern-js-bff-worker': bff.worker
+        }
+    });
+    return handler.length > 1 ? handler(mountedRequest, effectContext) : handler(mountedRequest);
+}
+export default {
+    async fetch (request, env, ctx) {
+        const corsPreflightResponse = createCorsPreflightResponse(request);
+        if (corsPreflightResponse) return corsPreflightResponse;
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return assetResponse;
+        const bffResponse = await dispatchBffRequest(request, env);
+        if (bffResponse) return withCorsHeaders(bffResponse);
+        const route = findRoute(request);
+        if (route?.worker) return withCorsHeaders(await dispatchRouteWorker(route, request, env, ctx));
+        const htmlResponse = await fetchRouteHtml(route, request, env);
+        if (htmlResponse) return htmlResponse;
+        return withCorsHeaders(new Response('Not found', {
+            status: 404
+        }));
+    }
+};

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/builder/generator/getBuilderEnvironments.mjs

@@ -1,5 +1,40 @@
+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'
+];
+function findExistingFile(candidates) {
+    return candidates.find((candidate)=>node_fs.existsSync(candidate));
+}
+function resolvePackageFile(packageName, filePath, paths) {
+    try {
+        const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+            paths
+        });
+        const packageFile = node_path.join(node_path.dirname(packageJsonPath), filePath);
+        return node_fs.existsSync(packageFile) ? node_fs.realpathSync(packageFile) : void 0;
+    } catch  {
+        return;
+    }
+}
+function setAliasIfPresent(alias, name, value) {
+    if (value) alias.set(name, value);
+}
+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 getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig) {
     const entries = {};
     const { entrypoints = [], checkedEntries } = appContext;
@@ -16,6 +51,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 +80,98 @@ 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 = normalizedConfig.deploy?.target === 'cloudflare';
+        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 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.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);
+                        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);
+                    }
+                } : {}
+            }
+        };
+    }
     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 };