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

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

@@ -43,17 +43,19 @@ 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 WRANGLER_CONFIG_FILE = 'wrangler.json';
-const OUTPUT_PACKAGE_FILE = 'package.json';
-const ASSETS_BINDING = 'ASSETS';
+const external_cloudflare_output_contract_js_namespaceObject = require("./cloudflare-output-contract.js");
+const external_cloudflare_output_plan_js_namespaceObject = require("./cloudflare-output-plan.js");
+const external_cloudflare_output_verifier_js_namespaceObject = require("./cloudflare-output-verifier.js");
+const WORKER_ENTRY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_ENTRY;
+const WRANGLER_CONFIG_FILE = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WRANGLER_CONFIG_FILE;
+const OUTPUT_PACKAGE_FILE = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+const ASSETS_BINDING = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_ASSETS_BINDING;
 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 PUBLIC_ASSETS_DIRECTORY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+const WORKER_BUNDLE_DIRECTORY = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
 const SERVER_BUNDLE_DIRECTORY = 'bundles';
 const SERVER_OUTPUT_DIRECTORY = 'server';
 const DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES = [
@@ -64,10 +66,7 @@ const BFF_EFFECT_WORKER_ENTRY = `${WORKER_BUNDLE_DIRECTORY}/__modern_bff_effect.
 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 REQUIRED_COMPATIBILITY_FLAGS = external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
 const RESERVED_ARTIFACT_DESTINATION_FILES = new Set([
     WRANGLER_CONFIG_FILE,
     OUTPUT_PACKAGE_FILE
@@ -261,11 +260,12 @@ const getConfiguredWorkerName = (appDirectory, modernConfig)=>{
     const configuredName = modernConfig.deploy?.worker?.name?.trim();
     return configuredName || getWorkerName(appDirectory);
 };
-const normalizeRelativePath = (value, label, scope = 'app output')=>{
+const normalizeRelativePath = (value, label, scope = 'app output', options = {})=>{
     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 || external_node_path_default().isAbsolute(normalized) || '.' === normalized || segments.includes('..')) throw new Error(`${label} must be a relative path inside the ${scope}.`);
+    const isRootDestination = '.' === normalized;
+    if (!normalized || external_node_path_default().isAbsolute(normalized) || !options.allowRoot && isRootDestination || segments.includes('..')) throw new Error(`${label} must be a relative path inside the ${scope}.`);
     return normalized;
 };
 const normalizeDirectiveValues = (value)=>{
@@ -420,9 +420,48 @@ const createWranglerD1Databases = (modernConfig, configuredWranglerD1)=>{
     if (!Array.isArray(d1Databases)) throw new Error('deploy.worker.d1Databases must be an array.');
     return d1Databases.map(normalizeD1Database);
 };
+const normalizeServiceBinding = (service, index)=>{
+    const binding = assertNonEmptyString(service.binding, `deploy.worker.services[${index}].binding`);
+    const serviceName = assertNonEmptyString(service.service, `deploy.worker.services[${index}].service`);
+    const prefix = void 0 === service.prefix ? void 0 : assertNonEmptyString(service.prefix, `deploy.worker.services[${index}].prefix`);
+    return {
+        binding,
+        service: serviceName,
+        ...void 0 === prefix ? {} : {
+            prefix
+        }
+    };
+};
+const createWorkerServiceBindings = (modernConfig, configuredWranglerServices)=>{
+    const services = modernConfig.deploy?.worker?.services;
+    if (void 0 === services) return configuredWranglerServices;
+    if (void 0 !== configuredWranglerServices) throw new Error('Use deploy.worker.services or deploy.worker.wrangler.services, not both.');
+    if (!Array.isArray(services)) throw new Error('deploy.worker.services must be an array.');
+    return services.map(normalizeServiceBinding);
+};
+const createWranglerServices = (serviceBindings)=>{
+    if (!Array.isArray(serviceBindings)) return serviceBindings;
+    if (!serviceBindings.every(isJsonRecord)) return serviceBindings;
+    return serviceBindings.map((service)=>{
+        const { prefix, ...wranglerService } = service;
+        return wranglerService;
+    });
+};
+const createWorkerManifestServiceBindings = (serviceBindings)=>{
+    if (!Array.isArray(serviceBindings)) return;
+    const dispatchBindings = serviceBindings.filter((service)=>isJsonRecord(service) && 'string' == typeof service.binding && 'string' == typeof service.service && 'string' == typeof service.prefix).map((service)=>({
+            binding: service.binding,
+            service: service.service,
+            prefix: service.prefix,
+            interface: 'fetch'
+        }));
+    return dispatchBindings.length > 0 ? dispatchBindings : void 0;
+};
 const createWranglerConfig = (appDirectory, modernConfig)=>{
     const wrangler = getConfiguredWrangler(modernConfig);
     const d1Databases = createWranglerD1Databases(modernConfig, wrangler.d1_databases);
+    const serviceBindings = createWorkerServiceBindings(modernConfig, wrangler.services);
+    const wranglerServices = createWranglerServices(serviceBindings);
     return {
         $schema: 'node_modules/wrangler/config-schema.json',
         name: getConfiguredWorkerName(appDirectory, modernConfig),
@@ -433,6 +472,9 @@ const createWranglerConfig = (appDirectory, modernConfig)=>{
         assets: createWranglerAssetsConfig(wrangler.assets),
         ...void 0 === d1Databases ? {} : {
             d1_databases: d1Databases
+        },
+        ...void 0 === wranglerServices ? {} : {
+            services: wranglerServices
         }
     };
 };
@@ -451,7 +493,9 @@ const normalizeCloudflareArtifact = (artifact, index)=>{
 const getCloudflareArtifacts = (modernConfig)=>(modernConfig.deploy?.worker?.artifacts ?? []).map(normalizeCloudflareArtifact);
 const normalizeCloudflarePublicAsset = (asset, index)=>{
     const from = normalizeRelativePath(asset.from, `deploy.worker.publicAssets[${index}].from`, 'app root');
-    const to = normalizeRelativePath(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output');
+    const to = normalizeRelativePath(asset.to, `deploy.worker.publicAssets[${index}].to`, 'Cloudflare public output', {
+        allowRoot: true
+    });
     return {
         from,
         to,
@@ -493,8 +537,79 @@ const readRouteSpec = async (outputDirectory)=>{
         routes: Array.isArray(routeSpec.routes) ? routeSpec.routes : []
     };
 };
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const ULTRAMODERN_BUILD_MODULE = 'shared/ultramodern-build.ts';
+const nonEmptyString = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+const toDeliveryUnitIdentity = (value)=>{
+    if (!isRecord(value)) return;
+    const unitId = nonEmptyString(value.unitId);
+    const buildMarker = nonEmptyString(value.buildMarker);
+    const sourceRevision = nonEmptyString(value.sourceRevision);
+    if (!unitId || !buildMarker || !sourceRevision) return;
+    return {
+        unitId,
+        buildMarker,
+        sourceRevision
+    };
+};
+const findWorkspaceRoot = async (appDirectory)=>{
+    let current = external_node_path_default().resolve(appDirectory);
+    for(;;){
+        if (await utils_namespaceObject.fs.pathExists(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = external_node_path_default().dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const resolveTopologyDeliveryUnit = async (appDirectory)=>{
+    const workspaceRoot = await findWorkspaceRoot(appDirectory);
+    if (!workspaceRoot) return;
+    let compactConfig;
+    try {
+        compactConfig = await utils_namespaceObject.fs.readJSON(external_node_path_default().join(workspaceRoot, COMPACT_CONFIG_PATH));
+    } catch  {
+        return;
+    }
+    if (!isRecord(compactConfig)) return;
+    const topology = isRecord(compactConfig.topology) ? compactConfig.topology : void 0;
+    const apps = Array.isArray(topology?.apps) ? topology.apps : [];
+    const resolvedAppDirectory = external_node_path_default().resolve(appDirectory);
+    for (const app of apps){
+        if (!isRecord(app)) continue;
+        const appPath = nonEmptyString(app.path);
+        if (appPath && external_node_path_default().resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory) return toDeliveryUnitIdentity(app.deliveryUnit);
+    }
+    return toDeliveryUnitIdentity(compactConfig.deliveryUnit);
+};
+const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
+    const buildModulePath = external_node_path_default().join(appDirectory, ULTRAMODERN_BUILD_MODULE);
+    if (!await utils_namespaceObject.fs.pathExists(buildModulePath)) return;
+    const source = await utils_namespaceObject.fs.readFile(buildModulePath, 'utf8');
+    const buildMarker = source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1];
+    const unitId = source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1];
+    const sourceRevision = source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1];
+    if (!buildMarker || !unitId || !sourceRevision) return;
+    const identity = {
+        unitId,
+        buildMarker,
+        sourceRevision
+    };
+    return {
+        ...identity,
+        surfaces: {
+            ui: {
+                ...identity,
+                surface: 'ui'
+            },
+            api: {
+                ...identity,
+                surface: 'api'
+            }
+        }
+    };
+};
 const createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect API runtime is configured, but the BFF worker bundle is missing: ${external_node_path_default().join(outputDirectory, worker)}. ${EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE}`);
-const createWorkerManifest = async (outputDirectory, modernConfig, appContext)=>{
+const createWorkerManifest = async (outputDirectory, modernConfig, appContext, deliveryUnitStamp)=>{
     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;
@@ -511,11 +626,12 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext)=>
     const primaryBffPrefix = Array.isArray(bffPrefix) ? bffPrefix[0] : bffPrefix;
     const isEffectApi = Boolean(modernConfig.bff) && modernConfig.bff?.runtimeFramework !== 'hono';
     const effectApiWorkerExists = await utils_namespaceObject.fs.pathExists(external_node_path_default().join(outputDirectory, BFF_EFFECT_WORKER_ENTRY));
+    const serviceBindings = createWorkerManifestServiceBindings(createWorkerServiceBindings(modernConfig, void 0));
     if (isEffectApi && primaryBffPrefix && !effectApiWorkerExists) throw createMissingEffectBffWorkerError(outputDirectory, BFF_EFFECT_WORKER_ENTRY);
     return {
         version: 1,
         runtime: {
-            type: 'cloudflare-module-worker',
+            type: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_RUNTIME_TYPE,
             entry: WORKER_ENTRY,
             fetchExport: true,
             nodeListen: false
@@ -531,7 +647,7 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext)=>
         },
         workerBundles: {
             directory: WORKER_BUNDLE_DIRECTORY,
-            format: 'commonjs',
+            format: external_cloudflare_output_contract_js_namespaceObject.CLOUDFLARE_WORKER_BUNDLE_FORMAT,
             importableFromModuleWorker: true,
             requestHandlerExport: 'requestHandler'
         },
@@ -540,12 +656,18 @@ const createWorkerManifest = async (outputDirectory, modernConfig, appContext)=>
             routeManifest: ROUTE_MANIFEST_FILE
         },
         security: createCloudflareWorkerSecurityPolicy(modernConfig),
+        ...deliveryUnitStamp ? {
+            deliveryUnit: deliveryUnitStamp
+        } : {},
         i18n: createI18nWorkerManifest(routeSpec, appContext),
         bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
             runtimeFramework: 'effect',
             prefix: primaryBffPrefix,
             worker: BFF_EFFECT_WORKER_ENTRY
-        } : void 0
+        } : void 0,
+        ...void 0 === serviceBindings ? {} : {
+            serviceBindings
+        }
     };
 };
 const createWorkerModuleLoaders = (manifest)=>{
@@ -597,11 +719,12 @@ const shouldCopyToWorkerBundle = (src, workerBundleDirectory)=>{
 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 outputPlan = (0, external_cloudflare_output_plan_js_namespaceObject.createCloudflareOutputPlan)(outputDirectory);
+    const publicDirectory = outputPlan.paths.publicAssets;
+    const workerEntryPath = outputPlan.paths.workerEntry;
+    const workerManifestPath = outputPlan.paths.workerManifest;
     const routeSpecOutputPath = external_node_path_default().join(outputDirectory, ROUTE_SPEC_OUTPUT);
-    const wranglerConfigPath = external_node_path_default().join(outputDirectory, WRANGLER_CONFIG_FILE);
+    const wranglerConfigPath = outputPlan.paths.wranglerConfig;
     const cloudflareArtifacts = getCloudflareArtifacts(modernConfig);
     const publicAssetExcludes = getPublicAssetExcludes(appDirectory, modernConfig);
     return {
@@ -617,14 +740,12 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
             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);
-            const workerBundleOutputDirectory = external_node_path_default().join(outputDirectory, WORKER_BUNDLE_DIRECTORY);
+            const workerBundleOutputDirectory = outputPlan.paths.workerBundle;
             if (await utils_namespaceObject.fs.pathExists(workerBundleSourceDirectory)) {
                 await utils_namespaceObject.fs.copy(workerBundleSourceDirectory, workerBundleOutputDirectory, {
                     filter: (src)=>shouldCopyToWorkerBundle(src, workerBundleSourceDirectory)
                 });
-                await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(workerBundleOutputDirectory, 'package.json'), {
-                    type: 'commonjs'
-                });
+                await utils_namespaceObject.fs.writeJSON(outputPlan.paths.workerPackage, outputPlan.packages.worker);
             }
             await copyCloudflareArtifacts(appDirectory, outputDirectory, cloudflareArtifacts);
             await copyCloudflarePublicAssets(appDirectory, publicDirectory, getCloudflarePublicAssets(modernConfig));
@@ -632,17 +753,24 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
             await utils_namespaceObject.fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
                 spaces: 2
             });
-            await utils_namespaceObject.fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig, appContext), {
+            const deliveryUnitStamp = await resolveWorkerDeliveryUnitStamp(appDirectory);
+            await utils_namespaceObject.fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig, appContext, deliveryUnitStamp), {
                 spaces: 2
             });
-            await utils_namespaceObject.fs.writeJSON(external_node_path_default().join(outputDirectory, OUTPUT_PACKAGE_FILE), {
-                type: 'module'
-            });
+            await utils_namespaceObject.fs.writeJSON(outputPlan.paths.outputPackage, outputPlan.packages.output);
         },
         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)));
+            const topologyDeliveryUnit = await resolveTopologyDeliveryUnit(appDirectory);
+            await (0, external_cloudflare_output_verifier_js_namespaceObject.assertCloudflareOutput)({
+                outputDirectory,
+                importWorker: false,
+                ...topologyDeliveryUnit ? {
+                    deliveryUnit: topologyDeliveryUnit
+                } : {}
+            });
         }
     };
 };

package/dist/cjs/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/index.mjs

@@ -8,6 +8,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";
@@ -28,6 +29,7 @@ const appTools = ()=>({
             initialize(),
             analyze(),
             serverBuild(),
+            backendFederationBuild(),
             deploy()
         ],
         post: [