@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/dist/cjs/release-envelope/framework-output.js

@@ -53,7 +53,7 @@ const promises_namespaceObject = require("node:fs/promises");
 var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const universal_namespaceObject = require("@modern-js/utils/universal");
+const backend_federation_contracts_namespaceObject = require("@modern-js/backend-federation-contracts");
 const external_index_js_namespaceObject = require("./index.js");
 const MICROVERTICAL_RELEASE_ENVELOPE_PATH = 'release/microvertical-release-envelope.json';
 const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH = 'release/microvertical-release-identity-carriers.json';
@@ -176,9 +176,9 @@ const writeReleaseEnvelope = async (artifactRoot, envelope)=>{
     await promises_default().writeFile(envelopePath, `${(0, external_index_js_namespaceObject.canonicalSerializeMicroVerticalReleaseEnvelope)(envelope)}\n`);
 };
 const readBuildArtifact = async (distDirectory)=>{
-    const artifactPath = external_node_path_default().join(distDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE);
+    const artifactPath = external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE);
     const artifact = await readJson(artifactPath);
-    if (!(0, universal_namespaceObject.isUltramodernBuildArtifact)(artifact)) throw new Error(`[ultramodern-release-envelope] ${universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE} is missing or invalid.`);
+    if (!(0, backend_federation_contracts_namespaceObject.isUltramodernBuildArtifact)(artifact)) throw new Error(`[ultramodern-release-envelope] ${backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE} is missing or invalid.`);
     if ('workspace' === artifact.deliveryUnit.sourceRevision) throw new Error('[ultramodern-release-envelope] sourceRevision "workspace" cannot produce a promotable full-stack envelope.');
     return artifact;
 };
@@ -195,7 +195,7 @@ const assertIdentityBlock = (value, identity, location, includeReleaseVersion)=>
     for (const [field, expectedValue] of Object.entries(expected))if (value[field] !== expectedValue) throw new Error(`[ultramodern-release-envelope] ${location}.${field} must match ${expectedValue}; received ${String(value[field])}.`);
 };
 const readBackendManifest = async (distDirectory, identity)=>{
-    const manifest = await readJson(external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE));
+    const manifest = await readJson(external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE));
     if (!isRecord(manifest) || !isRecord(manifest.backendFederation)) throw new Error('[ultramodern-release-envelope] backend federation manifest is missing backendFederation metadata.');
     assertIdentityBlock(manifest.backendFederation.deliveryUnit, identity, 'backendFederation.deliveryUnit', true);
     const versionBoundary = manifest.backendFederation.versionBoundary;
@@ -324,10 +324,10 @@ const createReleaseArtifactInputs = async (distDirectory, identity, target)=>{
     add(ssrPaths, 'node' === target ? 'nodejs' : 'workerd');
     add(apiBackendPaths, 'node' === target ? 'nodejs' : 'workerd-effect');
     add([
-        universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE
+        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE
     ], 'module-federation-manifest');
     add([
-        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
     ], 'node' === target ? 'nodejs' : 'commonjs-module');
     const surfaces = {
         uiClient: [
@@ -340,8 +340,8 @@ const createReleaseArtifactInputs = async (distDirectory, identity, target)=>{
             ...apiBackendPaths
         ].sort((left, right)=>left.localeCompare(right)),
         backendFederation: {
-            manifest: universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
-            container: universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+            manifest: backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+            container: backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
         }
     };
     const artifacts = [
@@ -350,8 +350,8 @@ const createReleaseArtifactInputs = async (distDirectory, identity, target)=>{
     const identityCarrierMetadata = await writeReleaseIdentityCarrierMetadata(distDirectory, identity, {
         apiBackend: apiBackendPaths,
         backendFederation: [
-            universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
-            universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+            backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+            backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
         ],
         ssr: [
             ...new Set([
@@ -379,8 +379,8 @@ const pathExists = async (filePath)=>{
 };
 const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirectory, target })=>{
     if (apiOnly) return;
-    const backendManifestPath = external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE);
-    const backendContainerPath = external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
+    const backendManifestPath = external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE);
+    const backendContainerPath = external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
     const [hasBackendManifest, hasBackendContainer] = await Promise.all([
         pathExists(backendManifestPath),
         pathExists(backendContainerPath)
@@ -428,9 +428,9 @@ const readFrameworkMicroVerticalReleaseEnvelope = async ({ artifactRoot, expecte
 const verifyBuildOutputReleaseEnvelope = async (distDirectory, expectedTarget)=>{
     const [hasEnvelope, hasBuildArtifact, hasBackendManifest, hasBackendEntry] = await Promise.all([
         pathExists(external_node_path_default().join(distDirectory, MICROVERTICAL_RELEASE_ENVELOPE_PATH)),
-        pathExists(external_node_path_default().join(distDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE)),
-        pathExists(external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE)),
-        pathExists(external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE))
+        pathExists(external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE)),
+        pathExists(external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE)),
+        pathExists(external_node_path_default().join(distDirectory, backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE))
     ]);
     const isFullStackMicroVertical = hasBuildArtifact && (hasBackendManifest || hasBackendEntry);
     return readFrameworkMicroVerticalReleaseEnvelope({
@@ -451,12 +451,12 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity)=
     for (const requiredPath of [
         'index.js',
         'package.json',
-        universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
-        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
     ])if (!files.includes(requiredPath)) throw new Error(`[ultramodern-release-envelope] final Node staging is missing ${requiredPath}.`);
     const backendFederationPaths = new Set([
-        universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
-        universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+        backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
     ]);
     const uiClientPaths = files.filter((logicalPath)=>{
         const topLevel = logicalPath.split('/')[0];
@@ -495,13 +495,13 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity)=
     for (const logicalPath of uiClientPaths)runtimeByPath.set(logicalPath, 'browser');
     for (const logicalPath of ssrPaths)runtimeByPath.set(logicalPath, 'nodejs');
     for (const logicalPath of apiBackendPaths)runtimeByPath.set(logicalPath, 'nodejs');
-    runtimeByPath.set(universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE, 'module-federation-manifest');
-    runtimeByPath.set(universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE, 'nodejs');
+    runtimeByPath.set(backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE, 'module-federation-manifest');
+    runtimeByPath.set(backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE, 'nodejs');
     const identityCarrierMetadata = await writeReleaseIdentityCarrierMetadata(outputDirectory, identity, {
         apiBackend: apiBackendPaths,
         backendFederation: [
-            universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
-            universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+            backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+            backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
         ],
         ssr: [
             ...new Set([
@@ -529,8 +529,8 @@ const createNodeStagedReleaseArtifactInputs = async (outputDirectory, identity)=
                 ...apiBackendPaths
             ].sort((left, right)=>left.localeCompare(right)),
             backendFederation: {
-                manifest: universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
-                container: universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+                manifest: backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE,
+                container: backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
             }
         }
     };
@@ -566,8 +566,8 @@ const createCloudflareStagedReleaseArtifactInputs = async (outputDirectory, iden
         'worker/package.json'
     ])if (!files.includes(requiredPath)) throw new Error(`[ultramodern-release-envelope] final Cloudflare staging is missing ${requiredPath}.`);
     if (files.some((logicalPath)=>'public/release' === logicalPath || logicalPath.startsWith('public/release/'))) throw new Error('[ultramodern-release-envelope] final Cloudflare envelope must remain private and cannot be staged under public/release.');
-    const backendManifestPath = `public/${universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}`;
-    const backendContainerPath = `public/${universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`;
+    const backendManifestPath = `public/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}`;
+    const backendContainerPath = `public/${backend_federation_contracts_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`;
     const apiBackendPaths = files.filter((logicalPath)=>EFFECT_BFF_WORKER_PATTERN.test(logicalPath));
     const ssrPaths = files.filter((logicalPath)=>(logicalPath.startsWith('server/') || logicalPath.startsWith('worker/')) && COMPILED_MODULE_PATTERN.test(logicalPath) && !EFFECT_BFF_WORKER_PATTERN.test(logicalPath));
     const uiClientPaths = files.filter((logicalPath)=>logicalPath.startsWith('public/') && logicalPath !== backendManifestPath && logicalPath !== backendContainerPath);

package/dist/cjs/release-envelope/plugin.js

@@ -52,7 +52,8 @@ const createUltramodernReleaseEnvelopePlugin = ({ resolveDeployTarget })=>({
         name: '@modern-js/ultramodern-release-envelope',
         pre: [
             '@modern-js/backend-federation-build',
-            '@modern-js/plugin-bff'
+            '@modern-js/plugin-bff',
+            '@modern-js/deploy-output-aliases'
         ],
         post: [
             '@modern-js/plugin-deploy'

package/dist/cjs/release-identity.js

@@ -38,11 +38,8 @@ const BUILD_MARKER_NAMESPACE = 'ultramodern-delivery-unit-release-build-marker:v
 const PROMOTABLE_SOURCE_REVISION_PATTERN = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u;
 const gitOutput = (workspaceRoot, args)=>{
     try {
-        return (0, external_node_child_process_namespaceObject.execFileSync)('git', [
-            '-C',
-            workspaceRoot,
-            ...args
-        ], {
+        return (0, external_node_child_process_namespaceObject.execFileSync)('git', args, {
+            cwd: workspaceRoot,
             encoding: 'utf8',
             stdio: [
                 'ignore',
@@ -77,7 +74,7 @@ const resolveUltramodernSourceRevision = (workspaceRoot = process.cwd(), configu
     ]);
     const status = gitOutput(gitRoot, [
         'status',
-        '--porcelain=v1',
+        '--porcelain',
         '--untracked-files=all'
     ]);
     if (!revision || void 0 === status || status.length > 0) return 'workspace';

package/dist/esm/backend-federation-build/codegen.mjs

@@ -0,0 +1,205 @@
+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/backend-federation-contracts";
+import { build } from "esbuild";
+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 = async (workspaceRoot, app, effectApiPath, entryPath)=>{
+    const effectApiSpecifier = createRelativeImportSpecifier(node_path.dirname(effectApiPath), effectApiPath);
+    const containerMetadata = {
+        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
+        } : {}
+    };
+    const compatibility = {
+        build: app.buildVersion,
+        contractVersion: BACKEND_FEDERATION_CONTRACT_VERSION,
+        nodeAdapterVersion: BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+        packageName: app.packageName,
+        ...app.unitId ? {
+            unitId: app.unitId
+        } : {},
+        ...app.sourceRevision ? {
+            sourceRevision: app.sourceRevision
+        } : {}
+    };
+    const source = `// Generated by Modern.js backend federation build.
+import * as exposedNamespace from ${JSON.stringify(effectApiSpecifier)};
+
+const exposedModule = {
+  ...exposedNamespace,
+  backendFederationContract: {
+    ...(exposedNamespace.backendFederationContract ?? {}),
+    compatibility: {
+      ...(exposedNamespace.backendFederationContract?.compatibility ?? {}),
+      ...${JSON.stringify(compatibility)},
+    },
+    name: ${JSON.stringify(app.backendName)},
+    role: 'microvertical-server',
+    runtimeFramework: 'effect',
+    strictEffectApproach: true,
+  },
+};
+const exposedModules = {
+  ${JSON.stringify(BACKEND_FEDERATION_EFFECT_EXPOSE)}: () => Promise.resolve(exposedModule),
+};
+const __modernjsBackendFederation = ${JSON.stringify(containerMetadata)};
+
+function init() {}
+
+function get(id) {
+  const load = exposedModules[id];
+  if (!load) {
+    throw new Error(\`Unexpected backend federation expose: \${id}\`);
+  }
+
+  return async () => load();
+}
+
+module.exports = { __modernjsBackendFederation, get, init };
+`;
+    const result = await build({
+        absWorkingDir: node_path.dirname(effectApiPath),
+        bundle: true,
+        format: 'cjs',
+        logLevel: 'silent',
+        platform: 'node',
+        stdin: {
+            contents: source,
+            loader: 'ts',
+            resolveDir: node_path.dirname(effectApiPath),
+            sourcefile: node_path.basename(entryPath)
+        },
+        target: 'node20',
+        write: false
+    });
+    const output = result.outputFiles[0];
+    if (!output) throw new Error('[backend-federation-build] CommonJS backend federation container emitted no output.');
+    return output.text;
+};
+const createBackendManifest = (workspaceRoot, distDirectory, app, entryIntegrity)=>{
+    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: {
+            ...entryIntegrity,
+            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',
+            appId: app.id,
+            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/backend-federation-build/config.mjs

@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { resolveUltramodernSourceRevision } from "@modern-js/app-tools-extensions/release-identity";
+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, isUltramodernBuildArtifact, validateDeliveryUnitRecord, validateUltramodernBuildArtifact } from "@modern-js/backend-federation-contracts";
+const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+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}.`);
+        if (!isUltramodernBuildArtifact(artifact)) 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)=>resolveUltramodernSourceRevision(workspaceRoot);
+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 configuredRemoteType = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.remoteType) ?? stringValue(compactApp.serverExecution?.node?.remoteType);
+    if (void 0 !== configuredRemoteType && 'commonjs-module' !== configuredRemoteType) throw new Error(`[backend-federation-build] Node backend federation remoteType must be "commonjs-module"; received "${configuredRemoteType}" for ${id}.`);
+    if (!new URL(containerEntry).pathname.endsWith(`/${BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`)) throw new Error(`[backend-federation-build] Node backend federation containerEntry must end with "/${BACKEND_FEDERATION_REMOTE_ENTRY_FILE}"; received "${containerEntry}" for ${id}.`);
+    const remoteType = 'commonjs-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/backend-federation-build/emit.mjs

@@ -0,0 +1,99 @@
+import { existsSync } from "node:fs";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import { resolveUltramodernReleaseIdentity } from "@modern-js/app-tools-extensions/release-identity";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, stampUltramodernBuildArtifactIdentity } from "@modern-js/backend-federation-contracts";
+import { createBackendFederationEntryIntegrity } from "@modern-js/server-runtime-extensions/backend-federation-security/node";
+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 generationBuildMarker = compactDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
+    const sourceRevision = await resolveWorkspaceSourceRevision(workspaceRoot);
+    const buildVersion = generationBuildMarker && unitId ? resolveUltramodernReleaseIdentity({
+        generationBuildMarker,
+        unitId,
+        workspaceRoot
+    }).buildMarker : void 0;
+    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 ? stampUltramodernBuildArtifactIdentity(buildIdentity.artifact, {
+        buildMarker: buildVersion ?? buildIdentity.artifact.deliveryUnit.buildMarker,
+        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;
+    const entrySource = await createBackendRemoteEntrySource(workspaceRoot, resolvedApp, effectApiPath, entryPath);
+    await promises.mkdir(distDirectory, {
+        recursive: true
+    });
+    await promises.writeFile(entryPath, entrySource);
+    await promises.writeFile(manifestPath, `${JSON.stringify(createBackendManifest(workspaceRoot, distDirectory, resolvedApp, createBackendFederationEntryIntegrity(entrySource)), 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/backend-federation-build/index.mjs

@@ -0,0 +1 @@
+export { default, emitBackendFederationArtifacts } from "./emit.mjs";