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

package/dist/esm-node/plugins/backend-federation/codegen.mjs

@@ -0,0 +1,158 @@
+import "node:module";
+import node_path from "node:path";
+import { BACKEND_FEDERATION_CONTRACT_VERSION, BACKEND_FEDERATION_EFFECT_EXPOSE, BACKEND_FEDERATION_NODE_ADAPTER_VERSION, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, formatBackendFederationValidationErrors, validateBackendFederationManifest } from "@modern-js/utils/universal";
+import { normalizeRelativePath } from "./config.mjs";
+const createRelativeImportSpecifier = (fromDirectory, toFile)=>{
+    const relativePath = normalizeRelativePath(node_path.relative(fromDirectory, toFile));
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+};
+const createPublicPath = (containerEntry, fallbackPort)=>{
+    try {
+        return new URL('.', containerEntry).href;
+    } catch  {
+        const slashIndex = containerEntry.lastIndexOf('/');
+        if (slashIndex >= 0) return containerEntry.slice(0, slashIndex + 1);
+        return `http://localhost:${fallbackPort}/`;
+    }
+};
+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_FEDERATION_EFFECT_EXPOSE)}: () =>
+    import(new URL(${JSON.stringify(effectApiSpecifier)}, import.meta.url).href),
+};
+
+export const __modernjsBackendFederation = ${JSON.stringify({
+        buildVersion: app.buildVersion,
+        expose: BACKEND_FEDERATION_EFFECT_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 = createPublicPath(app.containerEntry, app.port);
+    const manifest = {
+        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_FEDERATION_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            globalName: app.backendName,
+            publicPath,
+            ssrRemoteEntry: {
+                name: BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            ssrPublicPath: publicPath
+        },
+        entry: {
+            file: BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+            path: normalizeRelativePath(node_path.relative(workspaceRoot, node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE))),
+            type: app.remoteType,
+            url: app.containerEntry
+        },
+        exposes: [
+            {
+                id: `${app.backendName}:${BACKEND_FEDERATION_EFFECT_EXPOSE}`,
+                name: BACKEND_FEDERATION_EFFECT_EXPOSE,
+                path: '',
+                assets: {
+                    js: {
+                        async: [],
+                        sync: [
+                            BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+                        ]
+                    },
+                    css: {
+                        async: [],
+                        sync: []
+                    }
+                }
+            }
+        ],
+        shared: [],
+        backendFederation: {
+            role: 'microvertical-server',
+            name: app.backendName,
+            runtimeFramework: 'effect',
+            strictEffectApproach: true,
+            contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+            nodeAdapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+            remoteType: app.remoteType,
+            expose: BACKEND_FEDERATION_EFFECT_EXPOSE,
+            manifestUrl: app.manifestUrl,
+            containerEntry: app.containerEntry,
+            source: {
+                module: sourceModule
+            },
+            readinessPath: `${app.apiPrefix}/${app.apiStem}/readiness`,
+            openapiPath: `${app.apiPrefix}/openapi.json`,
+            ...app.deliveryUnit ? {
+                deliveryUnit: app.deliveryUnit
+            } : {},
+            versionBoundary: {
+                invariant: 'web-and-api-same-build',
+                packageName: app.packageName,
+                version: app.version,
+                buildVersion: app.buildVersion,
+                ...app.uiManifestUrl ? {
+                    uiManifestUrl: app.uiManifestUrl
+                } : {},
+                ...app.deliveryUnit ? {
+                    deliveryUnit: {
+                        unitId: app.deliveryUnit.unitId,
+                        buildMarker: app.deliveryUnit.buildMarker,
+                        sourceRevision: app.deliveryUnit.sourceRevision
+                    }
+                } : {}
+            }
+        }
+    };
+    const validation = validateBackendFederationManifest(manifest, {
+        path: 'backendFederationManifest',
+        requireEffectExpose: true,
+        requireEffectRuntime: true,
+        requireVersionFields: true
+    });
+    if (!validation.ok) throw new Error(`[backend-federation-build] Invalid backend federation manifest: ${formatBackendFederationValidationErrors(validation.errors)}.`);
+    return manifest;
+};
+export { createBackendManifest, createBackendRemoteEntrySource };

package/dist/esm-node/plugins/backend-federation/config.mjs

@@ -0,0 +1,142 @@
+import "node:module";
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { promisify } from "node:util";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, DELIVERY_UNIT_DEPLOY_PROFILE, DELIVERY_UNIT_KIND, DELIVERY_UNIT_SCHEMA_VERSION, ULTRAMODERN_BUILD_ARTIFACT_FILE, ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, deliveryUnitContractBlock, validateDeliveryUnitRecord, validateUltramodernBuildArtifact } from "@modern-js/utils/universal";
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const execFileAsync = promisify(execFile);
+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 buildArtifactPathFor = (appDirectory)=>node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
+const buildModulePathFor = (appDirectory)=>node_path.join(appDirectory, ULTRAMODERN_BUILD_MODULE_PATH);
+const readBuildIdentity = async (appDirectory)=>{
+    const buildArtifactPath = buildArtifactPathFor(appDirectory);
+    if (existsSync(buildArtifactPath)) {
+        const artifact = await readJsonFile(buildArtifactPath);
+        const artifactValidation = validateUltramodernBuildArtifact(artifact, buildArtifactPath);
+        if (!artifactValidation.ok) throw new Error(`[backend-federation-build] Invalid delivery-unit build artifact at ${buildArtifactPath}.`);
+        const deliveryUnit = artifact.deliveryUnit;
+        return {
+            artifact,
+            appId: deliveryUnit.appId,
+            buildVersion: deliveryUnit.buildMarker,
+            packageName: deliveryUnit.packageName,
+            version: deliveryUnit.version,
+            unitId: deliveryUnit.unitId,
+            sourceRevision: deliveryUnit.sourceRevision
+        };
+    }
+    const buildModulePath = buildModulePathFor(appDirectory);
+    if (!existsSync(buildModulePath)) return {};
+    console.warn(`[backend-federation-build] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ${ULTRAMODERN_BUILD_ARTIFACT_FILE}.`);
+    const source = await promises.readFile(buildModulePath, 'utf8');
+    return {
+        appId: source.match(/\bappId:\s*['"]([^'"]+)['"]/u)?.[1],
+        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 resolveWorkspaceSourceRevision = async (workspaceRoot)=>{
+    const envRevision = process.env.ULTRAMODERN_SOURCE_REVISION?.trim();
+    if (envRevision) return envRevision;
+    try {
+        const { stdout } = await execFileAsync('git', [
+            '-C',
+            workspaceRoot,
+            'rev-parse',
+            'HEAD'
+        ]);
+        const revision = stdout.trim();
+        if (revision.length > 0) return revision;
+    } catch  {}
+    console.warn('[backend-federation-build] Could not resolve git source revision; stamping sourceRevision as "workspace". Set ULTRAMODERN_SOURCE_REVISION to override.');
+    return 'workspace';
+};
+const createStampedDeliveryUnit = (input)=>{
+    if (!input.unitId || !input.buildMarker || !input.packageName || !input.version) return;
+    const record = {
+        schemaVersion: DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: DELIVERY_UNIT_KIND,
+        appId: input.appId,
+        unitId: input.unitId,
+        packageName: input.packageName,
+        version: input.version,
+        buildMarker: input.buildMarker,
+        sourceRevision: input.sourceRevision,
+        deployProfile: DELIVERY_UNIT_DEPLOY_PROFILE
+    };
+    const validation = validateDeliveryUnitRecord(record);
+    if (!validation.ok) return;
+    return deliveryUnitContractBlock(record);
+};
+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_FEDERATION_MANIFEST_FILE}`;
+    const containerEntry = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.containerEntry) ?? stringValue(compactApp.serverExecution?.node?.containerEntry) ?? `http://localhost:${port}/${BACKEND_FEDERATION_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;
+    }
+};
+export { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createAppFromCompactMetadata, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, normalizeRelativePath, readBuildIdentity, resolveWorkspaceSourceRevision };

package/dist/esm-node/plugins/backend-federation/emit.mjs

@@ -0,0 +1,89 @@
+import "node:module";
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, stampUltramodernBuildArtifactSourceRevision } from "@modern-js/utils/universal";
+import { createBackendManifest, createBackendRemoteEntrySource } from "./codegen.mjs";
+import { COMPACT_CONFIG_PATH, buildArtifactPathFor, buildModulePathFor, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, readBuildIdentity, resolveWorkspaceSourceRevision } from "./config.mjs";
+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 (hasBuildIdentity) {
+        const compactConfigPath = node_path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+        const buildIdentityPath = existsSync(buildArtifactPathFor(appDirectory)) ? buildArtifactPathFor(appDirectory) : buildModulePathFor(appDirectory);
+        const mismatches = [];
+        const compare = (label, a, b, leftLabel = 'deliveryUnit')=>{
+            if (void 0 !== a && void 0 !== b && a !== b) mismatches.push(`${label}: ${leftLabel}=${a} vs ultramodern-build=${b}`);
+        };
+        compare('appId', app.id, buildIdentity.appId, 'topology');
+        if (hasCompactDeliveryUnit) {
+            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} (topology) and ${buildIdentityPath}: ${mismatches.join('; ')}`);
+    }
+    const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+    const buildVersion = compactDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
+    const sourceRevision = await resolveWorkspaceSourceRevision(workspaceRoot);
+    const packageName = compactDeliveryUnit?.packageName ?? buildIdentity.packageName ?? app.packageName;
+    const version = compactDeliveryUnit?.version ?? buildIdentity.version;
+    const deliveryUnit = createStampedDeliveryUnit({
+        appId: app.id,
+        unitId,
+        buildMarker: buildVersion,
+        packageName,
+        version,
+        sourceRevision
+    });
+    const stampedBuildArtifact = buildIdentity.artifact ? stampUltramodernBuildArtifactSourceRevision(buildIdentity.artifact, sourceRevision) : void 0;
+    const resolvedApp = {
+        ...app,
+        packageName,
+        version,
+        buildVersion,
+        unitId,
+        sourceRevision,
+        deliveryUnit
+    };
+    const manifestPath = node_path.join(distDirectory, BACKEND_FEDERATION_MANIFEST_FILE);
+    const entryPath = node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
+    const deliveryUnitArtifactPath = stampedBuildArtifact ? node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE) : void 0;
+    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`);
+    if (stampedBuildArtifact && deliveryUnitArtifactPath) await promises.writeFile(deliveryUnitArtifactPath, `${JSON.stringify(stampedBuildArtifact, null, 2)}\n`);
+    return {
+        appId: resolvedApp.id,
+        manifestPath,
+        containerPath: entryPath,
+        ...deliveryUnitArtifactPath ? {
+            deliveryUnitArtifactPath
+        } : {},
+        remoteName: resolvedApp.backendName,
+        remoteType: resolvedApp.remoteType
+    };
+};
+const emit = ()=>({
+        name: '@modern-js/backend-federation-build',
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const { appDirectory, distDirectory } = api.getAppContext();
+                await emitBackendFederationArtifacts(appDirectory, distDirectory);
+            });
+        }
+    });
+export default emit;
+export { emitBackendFederationArtifacts };

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

@@ -0,0 +1,2 @@
+import "node:module";
+export { default, emitBackendFederationArtifacts } from "./backend-federation/emit.mjs";

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

@@ -0,0 +1,65 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_SPEC_OUTPUT } from "./constants.mjs";
+import { normalizeRelativePath } from "./utils.mjs";
+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 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', {
+        allowRoot: true
+    });
+    return {
+        from,
+        to,
+        index
+    };
+};
+const getCloudflarePublicAssets = (modernConfig)=>(modernConfig.deploy?.worker?.publicAssets ?? []).map(normalizeCloudflarePublicAsset);
+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 copyCloudflarePublicAssets = async (appDirectory, publicDirectory, publicAssets)=>{
+    for (const asset of publicAssets){
+        const sourcePath = node_path.join(appDirectory, asset.from);
+        if (!await fs.pathExists(sourcePath)) throw new Error(`deploy.worker.publicAssets[${asset.index}].from does not exist: ${asset.from}`);
+        await fs.copy(sourcePath, node_path.join(publicDirectory, asset.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 : []
+    };
+};
+export { copyCloudflareArtifacts, copyCloudflareD1Migrations, copyCloudflarePublicAssets, getCloudflareArtifacts, getCloudflarePublicAssets, readRouteSpec };

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

@@ -0,0 +1,34 @@
+import "node:module";
+import { CLOUDFLARE_ASSETS_BINDING, CLOUDFLARE_OUTPUT_PACKAGE_FILE, 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_WRANGLER_CONFIG_FILE } from "../cloudflare-output-contract.mjs";
+const WORKER_ENTRY = CLOUDFLARE_WORKER_ENTRY;
+const WORKER_MANIFEST = CLOUDFLARE_WORKER_MANIFEST;
+const WRANGLER_CONFIG_FILE = CLOUDFLARE_WRANGLER_CONFIG_FILE;
+const OUTPUT_PACKAGE_FILE = CLOUDFLARE_OUTPUT_PACKAGE_FILE;
+const ASSETS_BINDING = 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 = CLOUDFLARE_PUBLIC_ASSETS_DIRECTORY;
+const WORKER_BUNDLE_DIRECTORY = CLOUDFLARE_WORKER_BUNDLE_DIRECTORY;
+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 = CLOUDFLARE_REQUIRED_COMPATIBILITY_FLAGS;
+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
+]);
+export { ASSETS_BINDING, BFF_EFFECT_WORKER_ENTRY, CLOUDFLARE_RUNTIME_TYPE, CLOUDFLARE_WORKER_BUNDLE_FORMAT, COMPATIBILITY_DATE_PATTERN, DEFAULT_COMPATIBILITY_DATE, DEFAULT_SERVER_ONLY_PUBLIC_ASSET_EXCLUDES, EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE, LOADABLE_STATS_FILE, OUTPUT_PACKAGE_FILE, PUBLIC_ASSETS_DIRECTORY, REQUIRED_COMPATIBILITY_FLAGS, RESERVED_ARTIFACT_DESTINATION_DIRECTORIES, RESERVED_ARTIFACT_DESTINATION_FILES, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, ROUTE_SPEC_OUTPUT, SERVER_BUNDLE_DIRECTORY, SERVER_OUTPUT_DIRECTORY, WORKER_BUNDLE_DIRECTORY, WORKER_ENTRY, WORKER_MANIFEST, WRANGLER_CONFIG_FILE };

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

@@ -0,0 +1,68 @@
+import "node:module";
+import node_path from "node:path";
+import { fs } from "@modern-js/utils";
+import { ULTRAMODERN_BUILD_ARTIFACT_PATH, ULTRAMODERN_BUILD_MODULE_PATH, isUltramodernBuildArtifact, nonEmptyString, toDeliveryUnitIdentity } from "@modern-js/utils/universal";
+import { isRecord } from "./utils.mjs";
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const findWorkspaceRoot = async (appDirectory)=>{
+    let current = node_path.resolve(appDirectory);
+    for(;;){
+        if (await fs.pathExists(node_path.join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = node_path.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 fs.readJSON(node_path.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 = node_path.resolve(appDirectory);
+    for (const app of apps){
+        if (!isRecord(app)) continue;
+        const appPath = nonEmptyString(app.path);
+        if (appPath && node_path.resolve(workspaceRoot, appPath.replace(/^\.\/+/u, '')) === resolvedAppDirectory) return toDeliveryUnitIdentity(app.deliveryUnit);
+    }
+    return toDeliveryUnitIdentity(compactConfig.deliveryUnit);
+};
+const resolveWorkerDeliveryUnitStamp = async (appDirectory)=>{
+    const buildArtifactPath = node_path.join(appDirectory, ULTRAMODERN_BUILD_ARTIFACT_PATH);
+    const buildModulePath = node_path.join(appDirectory, ULTRAMODERN_BUILD_MODULE_PATH);
+    let identity;
+    if (await fs.pathExists(buildArtifactPath)) {
+        const artifact = await fs.readJSON(buildArtifactPath);
+        if (!isUltramodernBuildArtifact(artifact)) return;
+        identity = toDeliveryUnitIdentity(artifact.deliveryUnit);
+    } else if (await fs.pathExists(buildModulePath)) {
+        console.warn(`[cloudflare] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ultramodern-build.json.`);
+        const source = await fs.readFile(buildModulePath, 'utf8');
+        identity = toDeliveryUnitIdentity({
+            buildMarker: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+            unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+            sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
+        });
+    }
+    if (!identity) return;
+    return {
+        ...identity,
+        surfaces: {
+            ui: {
+                ...identity,
+                surface: 'ui'
+            },
+            api: {
+                ...identity,
+                surface: 'api'
+            }
+        }
+    };
+};
+export { resolveTopologyDeliveryUnit, resolveWorkerDeliveryUnitStamp };

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

@@ -0,0 +1,98 @@
+import "node:module";
+import { isRecord } from "./utils.mjs";
+const I18N_SERVER_PLUGIN_NAME = 'plugin-i18n/server';
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupHeader: 'accept-language'
+};
+const SERVER_SIDE_I18N_DETECTORS = new Set([
+    'querystring',
+    'cookie',
+    'header'
+]);
+const toStringArray = (value)=>Array.isArray(value) ? value.filter((entry)=>'string' == typeof entry) : [];
+const getI18nServerPlugin = (appContext)=>appContext.serverPlugins?.find((plugin)=>plugin.name.includes(I18N_SERVER_PLUGIN_NAME));
+const removeLocaleDetectionByEntry = (config)=>{
+    const { localeDetectionByEntry: _localeDetectionByEntry, ...rest } = config;
+    return rest;
+};
+const getEntryLocaleDetection = (entryName, localeDetection)=>{
+    const byEntry = isRecord(localeDetection.localeDetectionByEntry) ? localeDetection.localeDetectionByEntry : void 0;
+    const entryConfig = byEntry?.[entryName];
+    const globalConfig = removeLocaleDetectionByEntry(localeDetection);
+    return isRecord(entryConfig) ? {
+        ...globalConfig,
+        ...entryConfig
+    } : globalConfig;
+};
+const normalizeI18nDetection = (detection)=>{
+    const configured = isRecord(detection) ? detection : {};
+    const rawOrder = Array.isArray(configured.order) ? configured.order : DEFAULT_I18NEXT_DETECTION_OPTIONS.order;
+    const order = rawOrder.filter((entry)=>'string' == typeof entry && SERVER_SIDE_I18N_DETECTORS.has(entry));
+    return {
+        order: order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ],
+        lookupQuerystring: 'string' == typeof configured.lookupQuerystring && configured.lookupQuerystring ? configured.lookupQuerystring : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring,
+        lookupCookie: 'string' == typeof configured.lookupCookie && configured.lookupCookie ? configured.lookupCookie : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie,
+        lookupHeader: 'string' == typeof configured.lookupHeader && configured.lookupHeader ? configured.lookupHeader : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader
+    };
+};
+const normalizeLocalisedUrls = (localisedUrls)=>{
+    if (!isRecord(localisedUrls) || 0 === Object.keys(localisedUrls).length) return;
+    const normalized = {};
+    for (const [canonicalPath, languageMap] of Object.entries(localisedUrls)){
+        if (!isRecord(languageMap)) continue;
+        const normalizedLanguageMap = Object.fromEntries(Object.entries(languageMap).filter((entry)=>'string' == typeof entry[1] && entry[1].length > 0));
+        if (Object.keys(normalizedLanguageMap).length > 0) normalized[canonicalPath] = normalizedLanguageMap;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : void 0;
+};
+const normalizeWorkerI18nEntry = (entryName, localeDetection, staticRoutePrefixes)=>{
+    const entryConfig = getEntryLocaleDetection(entryName, localeDetection);
+    const languages = toStringArray(entryConfig.languages);
+    if (true !== entryConfig.localePathRedirect || 0 === languages.length) return;
+    const fallbackLanguage = 'string' == typeof entryConfig.fallbackLanguage && entryConfig.fallbackLanguage ? entryConfig.fallbackLanguage : 'en';
+    const ignoreRedirectRoutes = Array.isArray(entryConfig.ignoreRedirectRoutes) ? toStringArray(entryConfig.ignoreRedirectRoutes) : [];
+    const localisedUrls = normalizeLocalisedUrls(entryConfig.localisedUrls);
+    return {
+        i18nextDetector: false !== entryConfig.i18nextDetector,
+        languages,
+        fallbackLanguage,
+        detection: normalizeI18nDetection(entryConfig.detection),
+        ignoreRedirectRoutes,
+        staticRoutePrefixes,
+        ...localisedUrls ? {
+            localisedUrls
+        } : {}
+    };
+};
+const createI18nWorkerManifest = (routeSpec, appContext)=>{
+    const i18nServerPlugin = getI18nServerPlugin(appContext);
+    const localeDetection = i18nServerPlugin?.options?.localeDetection;
+    if (!isRecord(localeDetection)) return;
+    const staticRoutePrefixes = toStringArray(i18nServerPlugin?.options?.staticRoutePrefixes);
+    const entries = {};
+    for (const route of routeSpec.routes){
+        if ('string' != typeof route.entryName || entries[route.entryName]) continue;
+        const entry = normalizeWorkerI18nEntry(route.entryName, localeDetection, staticRoutePrefixes);
+        if (entry) entries[route.entryName] = entry;
+    }
+    return Object.keys(entries).length > 0 ? {
+        entries
+    } : void 0;
+};
+export { createI18nWorkerManifest };