@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.27 → 3.5.0-ultramodern.29

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

@@ -2,7 +2,7 @@ const ASSETS_BINDING = 'ASSETS';
 const MODERN_WORKER_MANIFEST = p_workerManifest;
 const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
 const workerModulePromises = new Map();
-const effectBffHandlerPromises = new Map();
+const effectBffDispatcherPromises = new Map();
 let effectEdgeRuntimePromise;
 const remoteJsonPromises = new Map();
 const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
@@ -152,17 +152,7 @@ async function createCorsPreflightResponse(request, env) {
             status: 204
         });
     }
-    if (!ASSET_CORS_ENABLED) return null;
-    const assets = env?.[ASSETS_BINDING];
-    if (!assets || 'function' != typeof assets.fetch) return null;
-    const assetResponse = await assets.fetch(new Request(request.url, {
-        method: 'HEAD'
-    }));
-    if (!assetResponse || 404 === assetResponse.status) return null;
-    return new Response(null, {
-        headers: ASSET_CORS_HEADERS,
-        status: 204
-    });
+    return null;
 }
 async function fetchAsset(request, env) {
     if ('GET' !== request.method && 'HEAD' !== request.method) return null;
@@ -798,17 +788,17 @@ async function dispatchBffRequest(request, env) {
     const defaultExport = workerModule.default;
     const runtime = getRuntimeModule(workerModule);
     if ('effect' === bff.runtimeFramework) {
-        let effectHandlerPromise = effectBffHandlerPromises.get(bff.worker);
-        if (!effectHandlerPromise) {
-            const { createEffectBffEdgeHandler } = await loadEffectEdgeRuntime();
-            effectHandlerPromise = createEffectBffEdgeHandler({
+        let effectDispatcherPromise = effectBffDispatcherPromises.get(bff.worker);
+        if (!effectDispatcherPromise) {
+            const { createEffectBffEdgeDispatcher } = await loadEffectEdgeRuntime();
+            effectDispatcherPromise = createEffectBffEdgeDispatcher({
                 module: runtime,
                 prefix: bff.prefix
             });
-            effectBffHandlerPromises.set(bff.worker, effectHandlerPromise);
+            effectBffDispatcherPromises.set(bff.worker, effectDispatcherPromise);
         }
-        const effectHandler = await effectHandlerPromise;
-        return effectHandler.handler(request, {
+        const effectDispatcher = await effectDispatcherPromise;
+        return effectDispatcher.dispatch(request, {
             env
         });
     }
@@ -836,12 +826,33 @@ async function dispatchBffRequest(request, env) {
     };
     return handler(mountedRequest, effectContext);
 }
+async function dispatchServiceBindingRequest(request, env) {
+    const serviceBindings = MODERN_WORKER_MANIFEST.serviceBindings;
+    if (!Array.isArray(serviceBindings) || 0 === serviceBindings.length) return null;
+    const pathname = new URL(request.url).pathname;
+    for (const binding of serviceBindings){
+        if (!binding?.binding || !binding?.prefix) continue;
+        if (!matchesPrefix(pathname, binding.prefix)) continue;
+        const service = env?.[binding.binding];
+        if (!service || 'function' != typeof service.fetch) return new Response(`Cloudflare service binding not available: ${binding.binding}`, {
+            status: 502,
+            headers: {
+                'content-type': 'text/plain; charset=utf-8',
+                'x-modern-js-service-binding': binding.binding
+            }
+        });
+        return service.fetch(request);
+    }
+    return null;
+}
 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)) {

package/dist/esm-node/index.mjs

@@ -10,6 +10,7 @@ import { compatPlugin } from "./compat/index.mjs";
 import { DEFAULT_RUNTIME_CONFIG_FILE } from "./constants.mjs";
 import { i18n } from "./locale/index.mjs";
 import analyze from "./plugins/analyze/index.mjs";
+import backendFederationBuild from "./plugins/backendFederationBuild.mjs";
 import deploy from "./plugins/deploy/index.mjs";
 import initialize from "./plugins/initialize/index.mjs";
 import serverBuild from "./plugins/serverBuild.mjs";
@@ -30,6 +31,7 @@ const appTools = ()=>({
             initialize(),
             analyze(),
             serverBuild(),
+            backendFederationBuild(),
             deploy()
         ],
         post: [

package/dist/esm-node/plugins/backendFederationBuild.mjs

@@ -0,0 +1,297 @@
+import "node:module";
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const BACKEND_MANIFEST_FILE = 'backend-mf-manifest.json';
+const BACKEND_REMOTE_ENTRY_FILE = 'backendRemoteEntry.mjs';
+const CONTRACT_VERSION = 'microvertical-server-effect-v1';
+const NODE_ADAPTER_VERSION = 'backend-mf-effect-v1';
+const BACKEND_EXPOSE = './effect-api';
+const normalizeRelativePath = (value)=>value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const readJsonFile = async (filePath)=>JSON.parse(await promises.readFile(filePath, 'utf8'));
+const buildModulePathFor = (appDirectory)=>node_path.join(appDirectory, 'shared/ultramodern-build.ts');
+const readBuildIdentity = async (appDirectory)=>{
+    const buildModulePath = buildModulePathFor(appDirectory);
+    if (!existsSync(buildModulePath)) return {};
+    const source = await promises.readFile(buildModulePath, 'utf8');
+    return {
+        buildVersion: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+        packageName: source.match(/\bpackageName:\s*['"]([^'"]+)['"]/u)?.[1],
+        version: source.match(/\bversion:\s*['"]([^'"]+)['"]/u)?.[1],
+        unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+        sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
+    };
+};
+const toPascalCase = (value)=>value.split(/[^a-zA-Z0-9]+/u).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
+const stringValue = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+const createBackendName = (app, id)=>{
+    const configuredName = stringValue(app.backendFederation?.name) ?? stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName) ?? stringValue(app.serverExecution?.node?.remoteName);
+    if (configuredName) return configuredName;
+    const mfName = stringValue(app.moduleFederation?.name);
+    return mfName ? `${mfName}Backend` : `vertical${toPascalCase(id)}Backend`;
+};
+const findWorkspaceRoot = (appDirectory)=>{
+    let current = appDirectory;
+    while(true){
+        if (existsSync(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = node_path.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const createAppFromCompactMetadata = (workspaceRoot, appDirectory, compactApp)=>{
+    const id = stringValue(compactApp.id);
+    const appPath = stringValue(compactApp.path);
+    if (!id || 'vertical' !== compactApp.kind || !isRecord(compactApp.api)) return;
+    const directory = appPath ? normalizeRelativePath(appPath) : `verticals/${id}`;
+    if (node_path.resolve(workspaceRoot, directory) !== node_path.resolve(appDirectory)) return;
+    const port = 'number' == typeof compactApp.port ? compactApp.port : void 0;
+    if (void 0 === port) return;
+    const apiPrefix = stringValue(compactApp.api.prefix) ?? `/${id}-api`;
+    const apiStem = stringValue(compactApp.api.stem) ?? id;
+    const backendName = createBackendName(compactApp, id);
+    const manifestUrl = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.manifestUrl) ?? stringValue(compactApp.serverExecution?.node?.manifestUrl) ?? `http://localhost:${port}/${BACKEND_MANIFEST_FILE}`;
+    const containerEntry = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.containerEntry) ?? stringValue(compactApp.serverExecution?.node?.containerEntry) ?? `http://localhost:${port}/${BACKEND_REMOTE_ENTRY_FILE}`;
+    const remoteType = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.remoteType) ?? stringValue(compactApp.serverExecution?.node?.remoteType) ?? 'module';
+    const packageName = stringValue(compactApp.package);
+    const uiManifestUrl = stringValue(compactApp.backendFederation?.versionBoundary?.ui?.manifestUrl) ?? stringValue(compactApp.moduleFederation?.manifestUrl);
+    const compactDeliveryUnit = isRecord(compactApp.deliveryUnit) ? {
+        unitId: stringValue(compactApp.deliveryUnit.unitId),
+        buildMarker: stringValue(compactApp.deliveryUnit.buildMarker),
+        sourceRevision: stringValue(compactApp.deliveryUnit.sourceRevision),
+        packageName: stringValue(compactApp.deliveryUnit.packageName),
+        version: stringValue(compactApp.deliveryUnit.version)
+    } : void 0;
+    return {
+        id,
+        directory,
+        packageName,
+        port,
+        apiPrefix,
+        apiStem,
+        backendName,
+        manifestUrl,
+        containerEntry,
+        remoteType,
+        uiManifestUrl,
+        compactDeliveryUnit
+    };
+};
+const findBackendFederationApp = async (workspaceRoot, appDirectory)=>{
+    const compactConfigPath = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+    const compactConfig = await readJsonFile(compactConfigPath);
+    const apps = Array.isArray(compactConfig.topology?.apps) ? compactConfig.topology.apps : [];
+    for (const app of apps){
+        const resolved = createAppFromCompactMetadata(workspaceRoot, appDirectory, app);
+        if (resolved) return resolved;
+    }
+};
+const createRelativeImportSpecifier = (fromDirectory, toFile)=>{
+    const relativePath = normalizeRelativePath(node_path.relative(fromDirectory, toFile));
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+};
+const createBackendRemoteEntrySource = (workspaceRoot, app, effectApiPath, entryPath)=>{
+    const effectApiSpecifier = createRelativeImportSpecifier(node_path.dirname(entryPath), effectApiPath);
+    return `// Generated by Modern.js backend federation build.
+const exposedModules = {
+  ${JSON.stringify(BACKEND_EXPOSE)}: () =>
+    import(new URL(${JSON.stringify(effectApiSpecifier)}, import.meta.url).href),
+};
+
+export const __modernjsBackendFederation = ${JSON.stringify({
+        buildVersion: app.buildVersion,
+        expose: BACKEND_EXPOSE,
+        name: app.backendName,
+        packageName: app.packageName,
+        remoteType: app.remoteType,
+        source: normalizeRelativePath(node_path.relative(workspaceRoot, effectApiPath)),
+        version: app.version,
+        ...app.unitId ? {
+            unitId: app.unitId
+        } : {},
+        ...app.sourceRevision ? {
+            sourceRevision: app.sourceRevision
+        } : {}
+    }, null, 2)};
+
+export function init() {}
+
+export function get(id) {
+  const load = exposedModules[id];
+  if (!load) {
+    throw new Error(\`Unexpected backend federation expose: \${id}\`);
+  }
+
+  return async () => load();
+}
+
+export default { get, init };
+`;
+};
+const createBackendManifest = (workspaceRoot, distDirectory, app)=>{
+    const sourceModule = `${app.directory}/api/effect-api.ts`;
+    const publicPath = `http://localhost:${app.port}/`;
+    return {
+        schemaVersion: 1,
+        id: app.backendName,
+        name: app.backendName,
+        version: app.version,
+        buildVersion: app.buildVersion,
+        metaData: {
+            name: app.backendName,
+            type: 'backend',
+            buildInfo: {
+                buildVersion: app.buildVersion,
+                buildName: app.packageName
+            },
+            remoteEntry: {
+                name: BACKEND_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            globalName: app.backendName,
+            publicPath,
+            ssrRemoteEntry: {
+                name: BACKEND_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            ssrPublicPath: publicPath
+        },
+        entry: {
+            file: BACKEND_REMOTE_ENTRY_FILE,
+            path: normalizeRelativePath(node_path.relative(workspaceRoot, node_path.join(distDirectory, BACKEND_REMOTE_ENTRY_FILE))),
+            type: app.remoteType,
+            url: app.containerEntry
+        },
+        exposes: [
+            {
+                id: `${app.backendName}:${BACKEND_EXPOSE}`,
+                name: BACKEND_EXPOSE,
+                path: '',
+                assets: {
+                    js: {
+                        async: [],
+                        sync: [
+                            BACKEND_REMOTE_ENTRY_FILE
+                        ]
+                    },
+                    css: {
+                        async: [],
+                        sync: []
+                    }
+                }
+            }
+        ],
+        shared: [],
+        backendFederation: {
+            role: 'microvertical-server',
+            name: app.backendName,
+            runtimeFramework: 'effect',
+            strictEffectApproach: true,
+            contractVersion: CONTRACT_VERSION,
+            nodeAdapterVersion: NODE_ADAPTER_VERSION,
+            remoteType: app.remoteType,
+            expose: BACKEND_EXPOSE,
+            manifestUrl: app.manifestUrl,
+            containerEntry: app.containerEntry,
+            source: {
+                module: sourceModule
+            },
+            readinessPath: `${app.apiPrefix}/${app.apiStem}/readiness`,
+            openapiPath: `${app.apiPrefix}/openapi.json`,
+            ...app.unitId && app.buildVersion ? {
+                deliveryUnit: {
+                    schemaVersion: 1,
+                    kind: 'microvertical-delivery-unit',
+                    unitId: app.unitId,
+                    packageName: app.packageName,
+                    version: app.version,
+                    buildMarker: app.buildVersion,
+                    sourceRevision: app.sourceRevision
+                }
+            } : {},
+            versionBoundary: {
+                invariant: 'web-and-api-same-build',
+                packageName: app.packageName,
+                version: app.version,
+                buildVersion: app.buildVersion,
+                ...app.uiManifestUrl ? {
+                    uiManifestUrl: app.uiManifestUrl
+                } : {},
+                ...app.unitId && app.buildVersion ? {
+                    deliveryUnit: {
+                        unitId: app.unitId,
+                        buildMarker: app.buildVersion
+                    }
+                } : {}
+            }
+        }
+    };
+};
+const emitBackendFederationArtifacts = async (appDirectory, distDirectory)=>{
+    const workspaceRoot = findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    const effectApiPath = node_path.join(appDirectory, 'api/effect-api.ts');
+    const backendFederationConfigPath = node_path.join(appDirectory, 'backend-federation.config.ts');
+    if (!existsSync(effectApiPath) || !existsSync(backendFederationConfigPath)) return;
+    const app = await findBackendFederationApp(workspaceRoot, appDirectory);
+    if (!app) return;
+    const buildIdentity = await readBuildIdentity(appDirectory);
+    const compactDeliveryUnit = app.compactDeliveryUnit;
+    const hasCompactDeliveryUnit = void 0 !== compactDeliveryUnit && (void 0 !== compactDeliveryUnit.unitId || void 0 !== compactDeliveryUnit.buildMarker || void 0 !== compactDeliveryUnit.packageName || void 0 !== compactDeliveryUnit.version);
+    const hasBuildIdentity = void 0 !== buildIdentity.unitId || void 0 !== buildIdentity.buildVersion || void 0 !== buildIdentity.packageName || void 0 !== buildIdentity.version;
+    if (hasCompactDeliveryUnit && hasBuildIdentity) {
+        const compactConfigPath = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+        const buildModulePath = buildModulePathFor(appDirectory);
+        const mismatches = [];
+        const compare = (label, a, b)=>{
+            if (void 0 !== a && void 0 !== b && a !== b) mismatches.push(`${label}: deliveryUnit=${a} vs ultramodern-build=${b}`);
+        };
+        compare('unitId', compactDeliveryUnit?.unitId, buildIdentity.unitId);
+        compare('buildMarker/build', compactDeliveryUnit?.buildMarker, buildIdentity.buildVersion);
+        compare('packageName', compactDeliveryUnit?.packageName, buildIdentity.packageName);
+        compare('version', compactDeliveryUnit?.version, buildIdentity.version);
+        if (mismatches.length > 0) throw new Error(`[backend-federation-build] Delivery-unit identity drift between ${compactConfigPath} (deliveryUnit) and ${buildModulePath}: ${mismatches.join('; ')}`);
+    }
+    const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+    const buildVersion = compactDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
+    const sourceRevision = compactDeliveryUnit?.sourceRevision ?? buildIdentity.sourceRevision;
+    const packageName = compactDeliveryUnit?.packageName ?? buildIdentity.packageName ?? app.packageName;
+    const version = compactDeliveryUnit?.version ?? buildIdentity.version;
+    const resolvedApp = {
+        ...app,
+        packageName,
+        version,
+        buildVersion,
+        unitId,
+        sourceRevision
+    };
+    const manifestPath = node_path.join(distDirectory, BACKEND_MANIFEST_FILE);
+    const entryPath = node_path.join(distDirectory, BACKEND_REMOTE_ENTRY_FILE);
+    await promises.mkdir(distDirectory, {
+        recursive: true
+    });
+    await promises.writeFile(entryPath, createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath));
+    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp), null, 2)}\n`);
+    return {
+        appId: resolvedApp.id,
+        manifestPath,
+        containerPath: entryPath,
+        remoteName: resolvedApp.backendName,
+        remoteType: resolvedApp.remoteType
+    };
+};
+const backendFederationBuild = ()=>({
+        name: '@modern-js/backend-federation-build',
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const { appDirectory, distDirectory } = api.getAppContext();
+                await emitBackendFederationArtifacts(appDirectory, distDirectory);
+            });
+        }
+    });
+export default backendFederationBuild;
+export { emitBackendFederationArtifacts };

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

@@ -0,0 +1,18 @@
+import "node:module";
+const CLOUDFLARE_WORKER_ENTRY = 'server/index.mjs';
+const CLOUDFLARE_WORKER_MANIFEST = 'server/modern-worker-manifest.json';
+const CLOUDFLARE_WRANGLER_CONFIG_FILE = 'wrangler.json';
+const CLOUDFLARE_OUTPUT_PACKAGE_FILE = 'package.json';
+const CLOUDFLARE_WORKER_PACKAGE_FILE = 'worker/package.json';
+const CLOUDFLARE_ASSETS_BINDING = 'ASSETS';
+const CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY = 'public';
+const CLOUDFLARE_WORKER_BUNDLE_DIRECTORY = 'worker';
+const CLOUDFLARE_RUNTIME_TYPE = 'cloudflare-module-worker';
+const CLOUDFLARE_OUTPUT_PACKAGE_TYPE = 'module';
+const CLOUDFLARE_WORKER_PACKAGE_TYPE = 'commonjs';
+const CLOUDFLARE_WORKER_BUNDLE_FORMAT = 'commonjs';
+const CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS = [
+    'nodejs_compat',
+    'global_fetch_strictly_public'
+];
+export { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_BUNDLE_FORMAT, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WORKER_PACKAGE_FILE, CLOUDFLARE_WORKER_PACKAGE_TYPE, CLOUDFLARE_WRANGLER_CONFIG_FILE };

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

@@ -0,0 +1,46 @@
+import "node:module";
+import node_path from "node:path";
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, CLOUDFLARE_OUTPUT_PACKAGE_TYPE, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY, CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_ENTRY, CLOUDFLARE_WORKER_MANIFEST, CLOUDFLARE_WORKER_PACKAGE_FILE, CLOUDFLARE_WORKER_PACKAGE_TYPE, CLOUDFLARE_WRANGLER_CONFIG_FILE } from "./cloudflare-output-contract.mjs";
+const resolveOutput = (outputDirectory, relativePath)=>node_path.join(outputDirectory, relativePath);
+function createCloudflareOutputPlan(outputDirectory) {
+    return {
+        outputDirectory,
+        requiredFiles: [
+            CLOUDFLARE_WORKER_ENTRY,
+            CLOUDFLARE_WORKER_MANIFEST,
+            CLOUDFLARE_WRANGLER_CONFIG_FILE,
+            CLOUDFLARE_OUTPUT_PACKAGE_FILE
+        ],
+        publicLeakDirectories: [
+            'server',
+            CLOUDFLARE_WORKER_BUNDLE_DIRECTORY
+        ],
+        paths: {
+            workerEntry: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_ENTRY),
+            workerManifest: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_MANIFEST),
+            wranglerConfig: resolveOutput(outputDirectory, CLOUDFLARE_WRANGLER_CONFIG_FILE),
+            outputPackage: resolveOutput(outputDirectory, CLOUDFLARE_OUTPUT_PACKAGE_FILE),
+            workerPackage: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_PACKAGE_FILE),
+            publicAssets: resolveOutput(outputDirectory, CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY),
+            workerBundle: resolveOutput(outputDirectory, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY)
+        },
+        packages: {
+            output: {
+                type: CLOUDFLARE_OUTPUT_PACKAGE_TYPE
+            },
+            worker: {
+                type: CLOUDFLARE_WORKER_PACKAGE_TYPE
+            }
+        },
+        wrangler: {
+            main: CLOUDFLARE_WORKER_ENTRY,
+            assets: {
+                binding: CLOUDFLARE_ASSETS_BINDING,
+                directory: `./${CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY}`,
+                run_worker_first: true
+            },
+            requiredCompatibilityFlags: CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS
+        }
+    };
+}
+export { createCloudflareOutputPlan };