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

package/dist/cjs/builder/generator/getBuilderEnvironments.js

@@ -1,5 +1,14 @@
 "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, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -26,8 +35,45 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     getBuilderEnvironments: ()=>getBuilderEnvironments
 });
+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 builder_namespaceObject = require("@modern-js/builder");
 const utils_namespaceObject = require("@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)=>external_node_fs_default().existsSync(candidate));
+}
+function resolvePackageFile(packageName, filePath, paths) {
+    try {
+        const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+            paths
+        });
+        const packageFile = external_node_path_default().join(external_node_path_default().dirname(packageJsonPath), filePath);
+        return external_node_fs_default().existsSync(packageFile) ? external_node_fs_default().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 ? external_node_path_default().isAbsolute(configuredEntry) ? configuredEntry : external_node_path_default().resolve(appContext.appDirectory, configuredEntry) : external_node_path_default().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;
@@ -44,6 +90,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: {
@@ -68,14 +119,98 @@ function getBuilderEnvironments(normalizedConfig, appContext, tempBuilderConfig)
         }
     };
     const useWorkerTarget = (0, utils_namespaceObject.isServiceWorker)(normalizedConfig);
-    if (useWorkerTarget) environments[builder_namespaceObject.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[builder_namespaceObject.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/cjs/builder/shared/builderPlugins/adapterBasic.js

@@ -43,8 +43,11 @@ const builderPluginAdapterBasic = (options)=>({
         setup (api) {
             api.modifyBundlerChain((chain, { target, CHAIN_ID, environment })=>{
                 const isServiceWorker = environment.name === builder_namespaceObject.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 = 'js';
                     chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(bareServerModuleReg);
@@ -60,8 +63,40 @@ const builderPluginAdapterBasic = (options)=>({
             });
             api.modifyRspackConfig((config, { target, environment })=>{
                 const isServiceWorker = environment.name === builder_namespaceObject.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',
@@ -102,7 +137,8 @@ const builderPluginAdapterBasic = (options)=>({
             });
         }
     });
-function applyNodeCompat(isServiceWorker, chain) {
+function applyNodeCompat(isServiceWorker, chain, options = {}) {
+    const { includeNodeExtensions = true } = options;
     const nodeExts = [
         '.node.js',
         '.node.jsx',
@@ -121,7 +157,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);
 }
 exports.builderPluginAdapterBasic = __webpack_exports__.builderPluginAdapterBasic;

package/dist/cjs/builder/shared/builderPlugins/adapterSSR.js

@@ -122,9 +122,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 = (0, utils_namespaceObject.isUseRsc)(normalizedConfig);
     await Promise.all(entrypoints.map(async (entrypoint)=>{
         const { entryName } = entrypoint;
         const serverLoadersFile = (0, utils_js_namespaceObject.getServerCombinedModuleFile)(internalDirectory, entryName);
@@ -132,6 +133,7 @@ async function applySSRLoaderEntry(chain, optinos, isServer) {
             await utils_namespaceObject.fs.access(serverLoadersFile, utils_namespaceObject.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/cjs/plugins/deploy/index.js

@@ -24,9 +24,12 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    default: ()=>deploy
+    default: ()=>deploy,
+    getSupportedDeployTargets: ()=>getSupportedDeployTargets,
+    resolveDeployTarget: ()=>resolveDeployTarget
 });
 const external_std_env_namespaceObject = require("std-env");
+const cloudflare_js_namespaceObject = require("./platforms/cloudflare.js");
 const gh_pages_js_namespaceObject = require("./platforms/gh-pages.js");
 const netlify_js_namespaceObject = require("./platforms/netlify.js");
 const node_js_namespaceObject = require("./platforms/node.js");
@@ -36,14 +39,18 @@ const deployPresets = {
     node: node_js_namespaceObject.createNodePreset,
     vercel: vercel_js_namespaceObject.createVercelPreset,
     netlify: netlify_js_namespaceObject.createNetlifyPreset,
-    ghPages: gh_pages_js_namespaceObject.createGhPagesPreset
+    ghPages: gh_pages_js_namespaceObject.createGhPagesPreset,
+    cloudflare: cloudflare_js_namespaceObject.createCloudflarePreset
 };
+const getSupportedDeployTargets = ()=>Object.keys(deployPresets);
+const isDeployTarget = (target)=>Object.prototype.hasOwnProperty.call(deployPresets, target);
+const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = external_std_env_namespaceObject.provider)=>modernConfig.deploy?.target || envDeployTarget || detectedProvider || 'node';
 async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = (0, index_js_namespaceObject.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,
@@ -54,12 +61,12 @@ async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
 const deploy = ()=>({
         name: '@modern-js/plugin-deploy',
         setup: (api)=>{
-            const deployTarget = process.env.MODERNJS_DEPLOY || external_std_env_namespaceObject.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();
@@ -69,8 +76,12 @@ const deploy = ()=>({
         }
     });
 exports["default"] = __webpack_exports__["default"];
+exports.getSupportedDeployTargets = __webpack_exports__.getSupportedDeployTargets;
+exports.resolveDeployTarget = __webpack_exports__.resolveDeployTarget;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "default"
+    "default",
+    "getSupportedDeployTargets",
+    "resolveDeployTarget"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/plugins/deploy/platforms/cloudflare.js

@@ -0,0 +1,220 @@
+"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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createCloudflarePreset: ()=>createCloudflarePreset
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("../utils/index.js");
+const WORKER_ENTRY = 'server/index.mjs';
+const WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const ASSETS_BINDING = 'ASSETS';
+const ROUTE_SPEC_FILE = 'route.json';
+const ROUTE_SPEC_OUTPUT = `server/${ROUTE_SPEC_FILE}`;
+const LOADABLE_STATS_FILE = 'loadable-stats.json';
+const ROUTE_MANIFEST_FILE = 'routes-manifest.json';
+const PUBLIC_ASSETS_DIRECTORY = 'public';
+const WORKER_BUNDLE_DIRECTORY = 'worker';
+const SERVER_BUNDLE_DIRECTORY = 'bundles';
+const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
+const getCompatibilityDate = ()=>new Date().toISOString().slice(0, 10);
+const getWorkerName = (appDirectory)=>{
+    const basename = external_node_path_default().basename(appDirectory);
+    return basename.replace(/[^a-zA-Z0-9-_]/g, '-') || 'modern-cloudflare-worker';
+};
+const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
+    const configuredName = modernConfig.deploy?.worker?.name?.trim();
+    return configuredName || getWorkerName(appDirectory);
+};
+const readRouteSpec = async (outputDirectory)=>{
+    const routeSpecPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    if (!await utils_namespaceObject.fs.pathExists(routeSpecPath)) return {
+        routes: []
+    };
+    const routeSpec = await utils_namespaceObject.fs.readJSON(routeSpecPath);
+    return {
+        ...routeSpec,
+        routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
+    };
+};
+const createWorkerManifest = async (outputDirectory, modernConfig)=>{
+    const routeSpec = await readRouteSpec(outputDirectory);
+    const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
+        const worker = 'string' == typeof route.worker ? route.worker : void 0;
+        return {
+            urlPath: route.urlPath,
+            entryName: route.entryName,
+            entryPath: route.entryPath,
+            isSSR: Boolean(route.isSSR),
+            worker,
+            workerExists: worker ? await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, worker)) : false
+        };
+    }));
+    const bffPrefix = modernConfig.bff?.prefix;
+    const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
+    const isEffectBff = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
+    const effectBffWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    return {
+        version: 1,
+        runtime: {
+            type: 'cloudflare-module-worker',
+            entry: WORKER_ENTRY,
+            fetchExport: true,
+            nodeListen: false
+        },
+        assets: {
+            binding: ASSETS_BINDING,
+            directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+            runWorkerFirst: true
+        },
+        routeSpec: {
+            file: ROUTE_SPEC_OUTPUT,
+            routes
+        },
+        workerBundles: {
+            directory: WORKER_BUNDLE_DIRECTORY,
+            format: 'esm',
+            importableFromModuleWorker: true,
+            requestHandlerExport: 'requestHandler'
+        },
+        resources: {
+            loadableStats: LOADABLE_STATS_FILE,
+            routeManifest: ROUTE_MANIFEST_FILE
+        },
+        bff: isEffectBff && primaryBffPrefix && effectBffWorkerExists ? {
+            runtimeFramework: 'effect',
+            prefix: primaryBffPrefix,
+            worker: BFF_EFFECT_WORKER_ENTRY
+        } : void 0
+    };
+};
+const createWorkerModuleLoaders = (manifest)=>{
+    const imports = new Map();
+    for (const route of manifest.routeSpec.routes)if (route.worker && route.workerExists) {
+        const importPath = `../${String(route.worker).replace(/^\/+/u, '')}`;
+        imports.set(route.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (manifest.bff?.worker) {
+        const importPath = `../${String(manifest.bff.worker).replace(/^\/+/u, '')}`;
+        imports.set(manifest.bff.worker, `() => import(${JSON.stringify(importPath)})`);
+    }
+    if (0 === imports.size) return '{}';
+    const loaders = [
+        ...imports.entries()
+    ].map(([worker, loader])=>`${JSON.stringify(worker)}: ${loader}`);
+    return `{\n${loaders.join(',\n')}\n}`;
+};
+const shouldCopyToPublicAssets = (src, distDirectory)=>{
+    const relativePath = external_node_path_default().relative(distDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const [topLevelDirectory] = normalizedRelativePath.split('/');
+    return normalizedRelativePath !== ROUTE_SPEC_FILE && topLevelDirectory !== WORKER_BUNDLE_DIRECTORY && topLevelDirectory !== SERVER_BUNDLE_DIRECTORY;
+};
+const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
+    const relativePath = external_node_path_default().relative(workerBundleDirectory, src);
+    if (!relativePath) return true;
+    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+    const basename = external_node_path_default().basename(normalizedRelativePath);
+    if (basename.startsWith('.') || normalizedRelativePath.includes('/.')) return false;
+    return [
+        '.cjs',
+        '.js',
+        '.mjs'
+    ].includes(external_node_path_default().extname(normalizedRelativePath));
+};
+const createCloudflarePreset = ({ appContext, modernConfig })=>{
+    const { appDirectory, distDirectory } = appContext;
+    const outputDirectory = external_node_path_default().join(appDirectory, '.output');
+    const publicDirectory = external_node_path_default().join(outputDirectory, PUBLIC_ASSETS_DIRECTORY);
+    const workerEntryPath = external_node_path_default().join(outputDirectory, WORKER_ENTRY);
+    const workerManifestPath = external_node_path_default().join(outputDirectory, WORKER_MANIFEST);
+    const routeSpecOutputPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
+    const wranglerConfigPath = external_node_path_default().join(outputDirectory, 'wrangler.json');
+    const workerName = getConfiguredWorkerName(appDirectory, modernConfig);
+    return {
+        async prepare () {
+            await utils_namespaceObject.fs.remove(outputDirectory);
+        },
+        async writeOutput () {
+            await utils_namespaceObject.fs.copy(distDirectory, publicDirectory, {
+                filter: (src)=>shouldCopyToPublicAssets(src, distDirectory)
+            });
+            await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerEntryPath));
+            await utils_namespaceObject.fs.ensureDir(external_node_path_default().dirname(workerManifestPath));
+            const routeSpecSourcePath = external_node_path_default().join(distDirectory, ROUTE_SPEC_FILE);
+            if (await utils_namespaceObject.fs.pathExists(routeSpecSourcePath)) await utils_namespaceObject.fs.copy(routeSpecSourcePath, routeSpecOutputPath);
+            const workerBundleSourceDirectory = external_node_path_default().join(distDirectory, WORKER_BUNDLE_DIRECTORY);
+            if (await utils_namespaceObject.fs.pathExists(workerBundleSourceDirectory)) await utils_namespaceObject.fs.copy(workerBundleSourceDirectory, external_node_path_default().join(outputDirectory, WORKER_BUNDLE_DIRECTORY), {
+                filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
+            });
+            await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, {
+                $schema: 'node_modules/wrangler/config-schema.json',
+                name: workerName,
+                main: WORKER_ENTRY,
+                compatibility_date: getCompatibilityDate(),
+                compatibility_flags: [
+                    'nodejs_compat'
+                ],
+                assets: {
+                    directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
+                    binding: ASSETS_BINDING,
+                    run_worker_first: true
+                }
+            }, {
+                spaces: 2
+            });
+            await utils_namespaceObject.fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
+                spaces: 2
+            });
+            await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, 'package.json'), {
+                type: 'module'
+            });
+        },
+        async genEntry () {
+            const template = await (0, index_js_namespaceObject.readTemplate)('cloudflare-entry.mjs');
+            const manifest = await utils_namespaceObject.fs.readJSON(workerManifestPath);
+            await utils_namespaceObject.fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
+        }
+    };
+};
+exports.createCloudflarePreset = __webpack_exports__.createCloudflarePreset;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCloudflarePreset"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});