@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/esm-node/plugins/deploy/platforms/cloudflare.mjs

@@ -1,493 +1,2 @@
 import "node:module";
-import node_path from "node:path";
-import { fs } from "@modern-js/utils";
-import { readTemplate } from "../utils/index.mjs";
-const WORKER_ENTRY = 'server/index.mjs';
-const WORKER_MANIFEST = 'server/modern-worker-manifest.json';
-const WRANGLER_CONFIG_FILE = 'wrangler.json';
-const OUTPUT_PACKAGE_FILE = 'package.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 SERVER_OUTPUT_DIRECTORY = 'server';
-const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
-    'api',
-    'shared'
-];
-const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.js`;
-const EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE = 'Ensure the Effect API entry exists at api/index.ts or bff.effect.entry, and import Cloudflare edge handlers from @modern-js/plugin-bff/effect-edge instead of lambda/Hono server helpers.';
-const DEFAULT_COMPATIBILITY_DATE = '2026-06-02';
-const COMPATIBILITY_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
-const REQUIRED_COMPATIBILITY_FLAGS = [
-    'nodejs_compat',
-    'global_fetch_strictly_public'
-];
-const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
-    WRANGLER_CONFIG_FILE,
-    OUTPUT_PACKAGE_FILE
-]);
-const RESERVED_ARTIFACT_DESTINATION_DIRECTORIES = new Set([
-    PUBLIC_ASSETS_DIRECTORY,
-    SERVER_OUTPUT_DIRECTORY,
-    WORKER_BUNDLE_DIRECTORY
-]);
-const DEFAULT_SECURITY_HEADERS = {
-    referrerPolicy: 'strict-origin-when-cross-origin',
-    contentTypeOptions: 'nosniff',
-    permissionsPolicy: 'camera=(), geolocation=(), microphone=(), payment=(), usb=()'
-};
-const DEFAULT_CORS_ALLOWED_METHODS = [
-    'GET',
-    'HEAD',
-    'POST',
-    'PUT',
-    'PATCH',
-    'DELETE',
-    'OPTIONS'
-];
-const DEFAULT_CSP_DIRECTIVES = {
-    'base-uri': [
-        "'self'"
-    ],
-    'connect-src': [
-        "'self'",
-        'https:',
-        'http:',
-        'wss:',
-        'ws:'
-    ],
-    'default-src': [
-        "'self'"
-    ],
-    'font-src': [
-        "'self'",
-        'data:',
-        'https:',
-        'http:'
-    ],
-    'form-action': [
-        "'self'"
-    ],
-    'frame-ancestors': [
-        "'self'"
-    ],
-    'img-src': [
-        "'self'",
-        'data:',
-        'blob:',
-        'https:',
-        'http:'
-    ],
-    'manifest-src': [
-        "'self'",
-        'https:',
-        'http:'
-    ],
-    'object-src': [
-        "'none'"
-    ],
-    "script-src": [
-        "'self'",
-        "'unsafe-inline'",
-        "'unsafe-eval'",
-        'https:',
-        'http:',
-        'blob:'
-    ],
-    'style-src': [
-        "'self'",
-        "'unsafe-inline'",
-        'https:',
-        'http:'
-    ],
-    'worker-src': [
-        "'self'",
-        'blob:'
-    ]
-};
-const getCompatibilityDate = (modernConfig)=>{
-    const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
-    const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
-    if (!COMPATIBILITY_DATE_PATTERN.test(compatibilityDate)) throw new Error(`deploy.worker.compatibilityDate must use YYYY-MM-DD, received ${JSON.stringify(compatibilityDate)}.`);
-    return compatibilityDate;
-};
-const getWorkerName = (appDirectory)=>{
-    const basename = node_path.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 normalizeRelativePath = (value, label, scope = 'app output')=>{
-    if ('string' != typeof value) throw new Error(`${label} must be a relative path inside the ${scope}.`);
-    const normalized = value.trim().replace(/\\/g, '/').replace(/^\.\/+/u, '').replace(/\/+$/u, '');
-    const segments = normalized.split('/');
-    if (!normalized || node_path.isAbsolute(normalized) || '.' === normalized || segments.includes('..')) throw new Error(`${label} must be a relative path inside the ${scope}.`);
-    return normalized;
-};
-const normalizeDirectiveValues = (value)=>{
-    const values = Array.isArray(value) ? value : [
-        value
-    ];
-    return [
-        ...new Set(values.map((entry)=>entry.trim()).filter(Boolean))
-    ];
-};
-const appendDirectiveValues = (directives, name, values)=>{
-    if (!values?.length) return;
-    directives[name] = normalizeDirectiveValues([
-        ...directives[name] ?? [],
-        ...values
-    ]);
-};
-const createContentSecurityPolicy = (config)=>{
-    const mode = config?.mode ?? 'report-only';
-    if ('off' === mode) return {
-        mode,
-        directives: {},
-        reason: config?.reason
-    };
-    const directives = Object.fromEntries(Object.entries(DEFAULT_CSP_DIRECTIVES).map(([name, values])=>[
-            name,
-            [
-                ...values
-            ]
-        ]));
-    for (const [name, value] of Object.entries(config?.directives ?? {}))if (false === value) delete directives[name];
-    else directives[name] = normalizeDirectiveValues(value);
-    if (config?.frameAncestors === false) delete directives['frame-ancestors'];
-    else if (config?.frameAncestors) directives['frame-ancestors'] = normalizeDirectiveValues(config.frameAncestors);
-    appendDirectiveValues(directives, "script-src", config?.additionalScriptSrc);
-    appendDirectiveValues(directives, 'style-src', config?.additionalStyleSrc);
-    appendDirectiveValues(directives, 'connect-src', config?.additionalConnectSrc);
-    appendDirectiveValues(directives, 'img-src', config?.additionalImgSrc);
-    if (config?.reportUri) directives['report-uri'] = [
-        config.reportUri
-    ];
-    return {
-        mode,
-        directives,
-        reason: config?.reason
-    };
-};
-const createNoindexPolicy = (noindex)=>{
-    if (false === noindex) return {
-        workersDev: false,
-        localhost: false,
-        previewHostnames: []
-    };
-    if (true === noindex || void 0 === noindex) return {
-        workersDev: true,
-        localhost: true,
-        previewHostnames: []
-    };
-    return {
-        workersDev: noindex.workersDev ?? true,
-        localhost: noindex.localhost ?? true,
-        previewHostnames: noindex.previewHostnames ?? [],
-        reason: noindex.reason
-    };
-};
-const createCloudflareWorkerCorsPolicy = (cors)=>({
-        assets: cors?.assets ?? true,
-        allowedOrigins: normalizeDirectiveValues(cors?.allowedOrigins ?? []),
-        allowedMethods: cors?.allowedMethods?.length ? normalizeDirectiveValues(cors.allowedMethods.map((method)=>method.toUpperCase())) : DEFAULT_CORS_ALLOWED_METHODS,
-        allowedHeaders: cors?.allowedHeaders?.length ? normalizeDirectiveValues(cors.allowedHeaders) : [
-            '*'
-        ],
-        reason: cors?.reason
-    });
-const createCloudflareWorkerSecurityPolicy = (modernConfig)=>{
-    const security = modernConfig.deploy?.worker?.security;
-    if (security?.enabled === false) return {
-        enabled: false,
-        cors: createCloudflareWorkerCorsPolicy(security.cors),
-        reason: security.reason
-    };
-    return {
-        enabled: true,
-        headers: {
-            referrerPolicy: security?.headers?.referrerPolicy ?? DEFAULT_SECURITY_HEADERS.referrerPolicy,
-            contentTypeOptions: security?.headers?.contentTypeOptions ?? DEFAULT_SECURITY_HEADERS.contentTypeOptions,
-            permissionsPolicy: security?.headers?.permissionsPolicy ?? DEFAULT_SECURITY_HEADERS.permissionsPolicy
-        },
-        contentSecurityPolicy: createContentSecurityPolicy(security?.contentSecurityPolicy),
-        noindex: createNoindexPolicy(security?.noindex),
-        cors: createCloudflareWorkerCorsPolicy(security?.cors),
-        reason: security?.reason
-    };
-};
-const isJsonRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
-const getConfiguredWrangler = (modernConfig)=>{
-    const wrangler = modernConfig.deploy?.worker?.wrangler;
-    if (void 0 === wrangler) return {};
-    if (!isJsonRecord(wrangler)) throw new Error('deploy.worker.wrangler must be a JSON object.');
-    return wrangler;
-};
-const createWranglerCompatibilityFlags = (configuredFlags)=>{
-    if (void 0 === configuredFlags) return [
-        ...REQUIRED_COMPATIBILITY_FLAGS
-    ];
-    if (!Array.isArray(configuredFlags) || configuredFlags.some((flag)=>'string' != typeof flag)) throw new Error('deploy.worker.wrangler.compatibility_flags must be an array of strings.');
-    return [
-        ...new Set([
-            ...configuredFlags,
-            ...REQUIRED_COMPATIBILITY_FLAGS
-        ])
-    ];
-};
-const createWranglerAssetsConfig = (configuredAssets)=>{
-    if (void 0 !== configuredAssets && !isJsonRecord(configuredAssets)) throw new Error('deploy.worker.wrangler.assets must be an object.');
-    return {
-        ...isJsonRecord(configuredAssets) ? configuredAssets : {},
-        directory: `./${PUBLIC_ASSETS_DIRECTORY}`,
-        binding: ASSETS_BINDING,
-        run_worker_first: true
-    };
-};
-const assertNonEmptyString = (value, label)=>{
-    if ('string' != typeof value || 0 === value.trim().length) throw new Error(`${label} must be a non-empty string.`);
-    return value.trim();
-};
-const normalizeD1Database = (database, index)=>{
-    const binding = assertNonEmptyString(database.binding, `deploy.worker.d1Databases[${index}].binding`);
-    const databaseName = assertNonEmptyString(database.databaseName, `deploy.worker.d1Databases[${index}].databaseName`);
-    const databaseId = assertNonEmptyString(database.databaseId, `deploy.worker.d1Databases[${index}].databaseId`);
-    const migrationsDir = void 0 === database.migrationsDir ? void 0 : normalizeRelativePath(database.migrationsDir, `deploy.worker.d1Databases[${index}].migrationsDir`, 'app root');
-    const previewDatabaseId = void 0 === database.previewDatabaseId ? void 0 : assertNonEmptyString(database.previewDatabaseId, `deploy.worker.d1Databases[${index}].previewDatabaseId`);
-    return {
-        binding,
-        database_name: databaseName,
-        database_id: databaseId,
-        ...void 0 === migrationsDir ? {} : {
-            migrations_dir: migrationsDir
-        },
-        ...void 0 === previewDatabaseId ? {} : {
-            preview_database_id: previewDatabaseId
-        },
-        ...void 0 === database.remote ? {} : {
-            remote: database.remote
-        }
-    };
-};
-const createWranglerD1Databases = (modernConfig, configuredWranglerD1)=>{
-    const d1Databases = modernConfig.deploy?.worker?.d1Databases;
-    if (void 0 === d1Databases) return configuredWranglerD1;
-    if (void 0 !== configuredWranglerD1) throw new Error('Use deploy.worker.d1Databases or deploy.worker.wrangler.d1_databases, not both.');
-    if (!Array.isArray(d1Databases)) throw new Error('deploy.worker.d1Databases must be an array.');
-    return d1Databases.map(normalizeD1Database);
-};
-const createWranglerConfig = (appDirectory, modernConfig)=>{
-    const wrangler = getConfiguredWrangler(modernConfig);
-    const d1Databases = createWranglerD1Databases(modernConfig, wrangler.d1_databases);
-    return {
-        $schema: 'node_modules/wrangler/config-schema.json',
-        name: getConfiguredWorkerName(appDirectory, modernConfig),
-        compatibility_date: getCompatibilityDate(modernConfig),
-        ...wrangler,
-        main: WORKER_ENTRY,
-        compatibility_flags: createWranglerCompatibilityFlags(wrangler.compatibility_flags),
-        assets: createWranglerAssetsConfig(wrangler.assets),
-        ...void 0 === d1Databases ? {} : {
-            d1_databases: d1Databases
-        }
-    };
-};
-const normalizeCloudflareArtifact = (artifact, index)=>{
-    const from = normalizeRelativePath(artifact.from, `deploy.worker.artifacts[${index}].from`, 'app root');
-    const to = normalizeRelativePath(artifact.to, `deploy.worker.artifacts[${index}].to`, 'Cloudflare output');
-    const [topLevelDestination] = to.split('/');
-    const reservedDestination = RESERVED_ARTIFACT_DESTINATION_FILES.has(to) ? to : topLevelDestination;
-    if (RESERVED_ARTIFACT_DESTINATION_FILES.has(to) || RESERVED_ARTIFACT_DESTINATION_DIRECTORIES.has(topLevelDestination)) throw new Error(`deploy.worker.artifacts[${index}].to must not target generated Cloudflare output path ${JSON.stringify(reservedDestination)}.`);
-    return {
-        from,
-        to,
-        index
-    };
-};
-const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
-const copyCloudflareArtifacts = async (appDirectory, outputDirectory, artifacts)=>{
-    for (const artifact of artifacts){
-        const sourcePath = node_path.join(appDirectory, artifact.from);
-        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.artifacts[${artifact.index}].from does not exist: ${artifact.from}`);
-        await fs.copy(sourcePath, node_path.join(outputDirectory, artifact.to));
-    }
-};
-const copyCloudflareD1Migrations = async (appDirectory, outputDirectory, modernConfig)=>{
-    for (const [index, database] of (modernConfig.deploy?.worker?.d1Databases ?? []).entries()){
-        if (!database.migrationsDir) continue;
-        const migrationsDir = normalizeRelativePath(database.migrationsDir, `deploy.worker.d1Databases[${index}].migrationsDir`, 'app root');
-        const sourcePath = node_path.join(appDirectory, migrationsDir);
-        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.d1Databases[${index}].migrationsDir does not exist: ${migrationsDir}`);
-        await fs.copy(sourcePath, node_path.join(outputDirectory, migrationsDir));
-    }
-};
-const readRouteSpec = async (outputDirectory)=>{
-    const routeSpecPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
-    if (!await fs.pathExists(routeSpecPath)) return {
-        routes: []
-    };
-    const routeSpec = await fs.readJSON(routeSpecPath);
-    return {
-        ...routeSpec,
-        routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
-    };
-};
-const createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect API runtime is configured, but the BFF worker bundle is missing: ${node_path.join(outputDirectory, worker)}. ${EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE}`);
-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 fs.pathExists(node_path.join(outputDirectory, worker)) : false
-        };
-    }));
-    const bffPrefix = modernConfig.bff?.prefix;
-    const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
-    const isEffectApi = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
-    const effectApiWorkerExists = await fs.pathExists(node_path.join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
-    if (isEffectApi && primaryBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(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: 'commonjs',
-            importableFromModuleWorker: true,
-            requestHandlerExport: 'requestHandler'
-        },
-        resources: {
-            loadableStats: LOADABLE_STATS_FILE,
-            routeManifest: ROUTE_MANIFEST_FILE
-        },
-        security: createCloudflareWorkerSecurityPolicy(modernConfig),
-        bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
-            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 getPublicAssetExcludes = (appDirectory, modernConfig)=>[
-        ...DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES.filter((directory)=>{
-            try {
-                return fs.statSync(node_path.join(appDirectory, directory)).isDirectory();
-            } catch  {
-                return false;
-            }
-        }),
-        ...modernConfig.deploy?.worker?.publicAssetExcludes ?? []
-    ].map((entry)=>normalizeRelativePath(entry, 'deploy.worker.publicAssetExcludes'));
-const shouldCopyToPublicAssets = (src, distDirectory, publicAssetExcludes)=>{
-    const relativePath = node_path.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 && !publicAssetExcludes.some((exclude)=>normalizedRelativePath === exclude || normalizedRelativePath.startsWith(`${exclude}/`));
-};
-const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
-    const relativePath = node_path.relative(workerBundleDirectory, src);
-    if (!relativePath) return true;
-    const normalizedRelativePath = relativePath.replace(/\\/g, '/');
-    const basename = node_path.basename(normalizedRelativePath);
-    if (basename.startsWith('.') || normalizedRelativePath.includes('/.')) return false;
-    if (fs.statSync(src).isDirectory()) return true;
-    return [
-        '.cjs',
-        '.js',
-        '.mjs'
-    ].includes(node_path.extname(normalizedRelativePath));
-};
-const createCloudflarePreset = ({ appContext, modernConfig })=>{
-    const { appDirectory, distDirectory } = appContext;
-    const outputDirectory = node_path.join(appDirectory, '.output');
-    const publicDirectory = node_path.join(outputDirectory, PUBLIC_ASSETS_DIRECTORY);
-    const workerEntryPath = node_path.join(outputDirectory, WORKER_ENTRY);
-    const workerManifestPath = node_path.join(outputDirectory, WORKER_MANIFEST);
-    const routeSpecOutputPath = node_path.join(outputDirectory, ROUTE_SPEC_OUTPUT);
-    const wranglerConfigPath = node_path.join(outputDirectory, WRANGLER_CONFIG_FILE);
-    const cloudflareArtifacts = getCloudflareArtifacts(modernConfig);
-    const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
-    return {
-        async prepare () {
-            await fs.remove(outputDirectory);
-        },
-        async writeOutput () {
-            await fs.copy(distDirectory, publicDirectory, {
-                filter: (src)=>shouldCopyToPublicAssets(src, distDirectory, publicAssetExcludes)
-            });
-            await fs.ensureDir(node_path.dirname(workerEntryPath));
-            await fs.ensureDir(node_path.dirname(workerManifestPath));
-            const routeSpecSourcePath = node_path.join(distDirectory, ROUTE_SPEC_FILE);
-            if (await fs.pathExists(routeSpecSourcePath)) await fs.copy(routeSpecSourcePath, routeSpecOutputPath);
-            const workerBundleSourceDirectory = node_path.join(distDirectory, WORKER_BUNDLE_DIRECTORY);
-            const workerBundleOutputDirectory = node_path.join(outputDirectory, WORKER_BUNDLE_DIRECTORY);
-            if (await fs.pathExists(workerBundleSourceDirectory)) {
-                await fs.copy(workerBundleSourceDirectory, workerBundleOutputDirectory, {
-                    filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
-                });
-                await fs.writeJSON(node_path.join(workerBundleOutputDirectory, 'package.json'), {
-                    type: 'commonjs'
-                });
-            }
-            await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
-            await copyCloudflareD1Migrations(appDirectory, outputDirectory, modernConfig);
-            await fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
-                spaces: 2
-            });
-            await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
-                spaces: 2
-            });
-            await fs.writeJSON(node_path.join(outputDirectory, OUTPUT_PACKAGE_FILE), {
-                type: 'module'
-            });
-        },
-        async genEntry () {
-            const template = await readTemplate('cloudflare-entry.mjs');
-            const manifest = await fs.readJSON(workerManifestPath);
-            await fs.writeFile(workerEntryPath, template.replace('p_workerManifest', JSON.stringify(manifest, null, 2)).replace('p_workerModuleLoaders', createWorkerModuleLoaders(manifest)));
-        }
-    };
-};
-export { createCloudflarePreset };
+export { createCloudflarePreset } from "./cloudflare/index.mjs";

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-entry.001-bootstrap-security.mjs

@@ -0,0 +1,22 @@
+const MODERN_WORKER_MANIFEST = p_workerManifest;
+p_workerModuleLoaders;
+new Map();
+new Map();
+new Map();
+const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
+CORS_POLICY.assets;
+(CORS_POLICY.allowedOrigins || []).map((origin)=>String(origin).toLowerCase());
+(CORS_POLICY.allowedMethods?.length ? CORS_POLICY.allowedMethods : [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'OPTIONS'
+]).join(', ');
+(CORS_POLICY.allowedHeaders?.length ? CORS_POLICY.allowedHeaders : [
+    '*'
+]).join(', ');
+globalThis.__dirname ??= '/';
+globalThis.__filename ??= '/index.js';

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-entry.006-fetch-handler.mjs

@@ -0,0 +1,32 @@
+export default {
+    async fetch (request, env, ctx) {
+        const corsPreflightResponse = await createCorsPreflightResponse(request, env);
+        if (corsPreflightResponse) return finalizeResponseForRequest(corsPreflightResponse, request);
+        const bffResponse = await dispatchBffRequest(request, env);
+        if (bffResponse) return finalizeResponseForRequest(withAppCorsHeaders(bffResponse, request), request);
+        const serviceBindingResponse = await dispatchServiceBindingRequest(request, env);
+        if (serviceBindingResponse) return finalizeResponseForRequest(withAppCorsHeaders(serviceBindingResponse, request), request);
+        const route = findRoute(request);
+        const { pathname } = new URL(request.url);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) {
+            const assetResponse = await fetchAsset(request, env);
+            if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+            return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+                status: 404
+            }), request), request);
+        }
+        const localeRedirectResponse = createLocaleRedirectResponseForRequest(route, request);
+        if (localeRedirectResponse) return finalizeResponseForRequest(withAppCorsHeaders(localeRedirectResponse, request), request);
+        if (route?.worker) {
+            const renderableRequest = createRenderableRequest(request);
+            return finalizeResponseForRequest(withAppCorsHeaders(await dispatchRouteWorker(route, renderableRequest, env, ctx), request), request);
+        }
+        const htmlResponse = await fetchRouteHtml(route, request, env);
+        if (htmlResponse) return finalizeResponseForRequest(htmlResponse, request);
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+        return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+            status: 404
+        }), request), request);
+    }
+};

package/dist/types/plugins/backend-federation/codegen.d.ts

@@ -0,0 +1,82 @@
+import { type BackendFederationApp } from './config';
+export declare const createBackendRemoteEntrySource: (workspaceRoot: string, app: BackendFederationApp, effectApiPath: string, entryPath: string) => string;
+export declare const createBackendManifest: (workspaceRoot: string, distDirectory: string, app: BackendFederationApp) => {
+    schemaVersion: number;
+    id: string;
+    name: string;
+    version: string | undefined;
+    buildVersion: string | undefined;
+    metaData: {
+        name: string;
+        type: string;
+        buildInfo: {
+            buildVersion: string | undefined;
+            buildName: string | undefined;
+        };
+        remoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        globalName: string;
+        publicPath: string;
+        ssrRemoteEntry: {
+            name: string;
+            path: string;
+            type: string;
+        };
+        ssrPublicPath: string;
+    };
+    entry: {
+        file: string;
+        path: string;
+        type: string;
+        url: string;
+    };
+    exposes: {
+        id: string;
+        name: string;
+        path: string;
+        assets: {
+            js: {
+                async: never[];
+                sync: string[];
+            };
+            css: {
+                async: never[];
+                sync: never[];
+            };
+        };
+    }[];
+    shared: never[];
+    backendFederation: {
+        role: string;
+        name: string;
+        runtimeFramework: string;
+        strictEffectApproach: boolean;
+        contractVersion: string;
+        nodeAdapterVersion: string;
+        remoteType: string;
+        expose: string;
+        manifestUrl: string;
+        containerEntry: string;
+        source: {
+            module: string;
+        };
+        readinessPath: string;
+        openapiPath: string;
+        deliveryUnit?: import("@modern-js/utils/universal").DeliveryUnitContractBlock | undefined;
+        versionBoundary: {
+            invariant: string;
+            packageName: string | undefined;
+            version: string | undefined;
+            buildVersion: string | undefined;
+            uiManifestUrl?: string | undefined;
+            deliveryUnit?: {
+                unitId: string;
+                buildMarker: string;
+                sourceRevision: string;
+            } | undefined;
+        };
+    };
+};