@bleedingdev/modern-js-app-tools-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/esm/release-envelope/framework-output.mjs

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 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, isUltramodernBuildArtifact } from "@modern-js/utils/universal";
+import { BACKEND_FEDERATION_MANIFEST_FILE, BACKEND_FEDERATION_REMOTE_ENTRY_FILE, ULTRAMODERN_BUILD_ARTIFACT_FILE, isUltramodernBuildArtifact } from "@modern-js/backend-federation-contracts";
 import { canonicalSerializeMicroVerticalReleaseEnvelope, createMicroVerticalReleaseEnvelope, verifyMicroVerticalReleaseEnvelope } from "./index.mjs";
 const MICROVERTICAL_RELEASE_ENVELOPE_PATH = 'release/microvertical-release-envelope.json';
 const MICROVERTICAL_RELEASE_IDENTITY_CARRIERS_PATH = 'release/microvertical-release-identity-carriers.json';
@@ -21,6 +21,46 @@ const collectNestedStrings = (value, key)=>{
             ...collectNestedStrings(entryValue, key)
         ]);
 };
+const emptyProducerRouteModules = async (distDirectory, files, manifest, manifestLogicalPath)=>{
+    if (!isRecord(manifest) || !Array.isArray(manifest.exposes) || 0 !== manifest.exposes.length || !Array.isArray(manifest.remotes) || 0 !== manifest.remotes.length || !isRecord(manifest.metaData) || !isRecord(manifest.metaData.remoteEntry) || '' !== manifest.metaData.remoteEntry.name || '' !== manifest.metaData.remoteEntry.path || 'global' !== manifest.metaData.remoteEntry.type) return [];
+    const publicPath = manifest.metaData.publicPath;
+    const safeReference = (value)=>'string' == typeof value && value.length > 0 && !/[\\\\%?#\s]/u.test(value) && !value.split('/').some((segment)=>'.' === segment || '..' === segment);
+    if (!safeReference(publicPath)) return [];
+    const absoluteBase = /^https?:\/\//u.test(publicPath);
+    if ('auto' !== publicPath && (!publicPath.endsWith('/') || !absoluteBase && (!publicPath.startsWith('/') || publicPath.startsWith('//')))) return [];
+    if (absoluteBase) {
+        const base = new URL(publicPath);
+        if (base.username || base.password || base.href !== publicPath) return [];
+    }
+    const directory = node_path.posix.dirname(manifestLogicalPath);
+    const routesManifest = await readJson(node_path.join(distDirectory, directory, 'routes-manifest.json'));
+    if (!isRecord(routesManifest) || !isRecord(routesManifest.routeAssets)) return [];
+    const modules = new Set();
+    for (const route of Object.values(routesManifest.routeAssets)){
+        if (!isRecord(route) || !Array.isArray(route.assets)) return [];
+        for (const reference of route.assets){
+            if (!safeReference(reference) || reference.startsWith('//')) return [];
+            let relative = reference;
+            if (/^https?:\/\//u.test(reference)) {
+                if (!absoluteBase || !reference.startsWith(publicPath)) return [];
+                relative = reference.slice(publicPath.length);
+            } else if (reference.startsWith('/')) {
+                const prefix = 'auto' === publicPath ? '/' : absoluteBase ? new URL(publicPath).pathname : publicPath;
+                if (!reference.startsWith(prefix)) return [];
+                relative = reference.slice(prefix.length);
+            }
+            if (!/^(?:static|html|public)\/[^:]+$/u.test(relative) || relative.includes('//')) return [];
+            const logicalPath = node_path.posix.join(directory, relative);
+            if (!files.includes(logicalPath)) return [];
+            const assetStat = await promises.lstat(node_path.join(distDirectory, logicalPath));
+            if (!assetStat.isFile()) return [];
+            if (COMPILED_MODULE_PATTERN.test(logicalPath)) modules.add(logicalPath);
+        }
+    }
+    return [
+        ...modules
+    ];
+};
 const manifestReferencedClientModules = async (distDirectory, files, manifestLogicalPath = 'mf-manifest.json')=>{
     const manifest = await readJson(node_path.join(distDirectory, manifestLogicalPath));
     const references = [
@@ -30,9 +70,10 @@ const manifestReferencedClientModules = async (distDirectory, files, manifestLog
         ...collectNestedStrings(manifest, 'async')
     ];
     const normalizedReferences = new Set(references.filter((value)=>'string' == typeof value).map((value)=>value.replace(/^https?:\/\/[^/]+/u, '')).map((value)=>value.replace(/^\/+/u, '')));
-    return files.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath) && [
+    const modules = files.filter((logicalPath)=>COMPILED_MODULE_PATTERN.test(logicalPath) && [
             ...normalizedReferences
         ].some((reference)=>reference === logicalPath || reference.endsWith(`/${logicalPath}`) || logicalPath.endsWith(`/${reference}`)));
+    return modules.length > 0 ? modules : emptyProducerRouteModules(distDirectory, files, manifest, manifestLogicalPath);
 };
 const routeReferencedSsrModules = async (distDirectory, files, target, routeSpecLogicalPath = 'route.json')=>{
     const routeSpec = await readJson(node_path.join(distDirectory, routeSpecLogicalPath));
@@ -82,11 +123,14 @@ const writeReleaseEnvelope = async (artifactRoot, envelope)=>{
     if (!envelopePath) throw new Error('[ultramodern-release-envelope] could not resolve release envelope path.');
     await promises.writeFile(envelopePath, `${canonicalSerializeMicroVerticalReleaseEnvelope(envelope)}\n`);
 };
-const readBuildArtifact = async (distDirectory)=>{
+const readBuildArtifact = async (distDirectory, requirePromotable = true)=>{
     const artifactPath = node_path.join(distDirectory, ULTRAMODERN_BUILD_ARTIFACT_FILE);
     const artifact = await readJson(artifactPath);
     if (!isUltramodernBuildArtifact(artifact)) throw new Error(`[ultramodern-release-envelope] ${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.');
+    if ('workspace' === artifact.deliveryUnit.sourceRevision) {
+        if (!requirePromotable) return;
+        throw new Error('[ultramodern-release-envelope] sourceRevision "workspace" cannot produce a promotable full-stack envelope.');
+    }
     return artifact;
 };
 const assertIdentityBlock = (value, identity, location, includeReleaseVersion)=>{
@@ -284,7 +328,7 @@ const pathExists = async (filePath)=>{
         return false;
     }
 };
-const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirectory, target })=>{
+const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirectory, requirePromotable = true, target })=>{
     if (apiOnly) return;
     const backendManifestPath = node_path.join(distDirectory, BACKEND_FEDERATION_MANIFEST_FILE);
     const backendContainerPath = node_path.join(distDirectory, BACKEND_FEDERATION_REMOTE_ENTRY_FILE);
@@ -294,7 +338,8 @@ const emitFrameworkMicroVerticalReleaseEnvelope = async ({ apiOnly, distDirector
     ]);
     if (!hasBackendManifest && !hasBackendContainer) return;
     if (!hasBackendManifest || !hasBackendContainer) throw new Error('[ultramodern-release-envelope] full-stack MicroVertical backend federation manifest and container must be emitted together.');
-    const buildArtifact = await readBuildArtifact(distDirectory);
+    const buildArtifact = await readBuildArtifact(distDirectory, requirePromotable);
+    if (!buildArtifact) return;
     const identity = {
         unitId: buildArtifact.deliveryUnit.unitId,
         buildMarker: buildArtifact.deliveryUnit.buildMarker,

package/dist/esm/release-envelope/plugin.mjs

@@ -10,24 +10,26 @@ 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'
         ],
         setup (api) {
-            const emitBuildEnvelope = async (target)=>{
+            const emitBuildEnvelope = async (target, requirePromotable = true)=>{
                 const { apiOnly, distDirectory } = api.getAppContext();
                 await emitFrameworkMicroVerticalReleaseEnvelope({
                     apiOnly,
                     distDirectory,
+                    requirePromotable,
                     target
                 });
             };
             api.onAfterBuild(async ()=>{
                 const configuredTarget = resolveDeployTarget(api.getNormalizedConfig());
                 if ('node' !== configuredTarget && 'cloudflare' !== configuredTarget) return;
-                await emitBuildEnvelope(configuredTarget);
+                await emitBuildEnvelope(configuredTarget, false);
             });
             api.onBeforeDeploy(async ()=>{
                 const configuredTarget = resolveActiveDeployTarget(api, resolveDeployTarget);

package/dist/esm/release-identity.mjs

@@ -4,11 +4,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 execFileSync('git', [
-            '-C',
-            workspaceRoot,
-            ...args
-        ], {
+        return execFileSync('git', args, {
+            cwd: workspaceRoot,
             encoding: 'utf8',
             stdio: [
                 'ignore',
@@ -43,7 +40,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/runtime-package-resolution.mjs

@@ -0,0 +1,60 @@
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+const findHostingModuleDirectory = (packageName, fromDirectory)=>{
+    let directory = node_path.resolve(fromDirectory);
+    for(;;){
+        const candidate = node_path.join(directory, 'node_modules');
+        if (node_fs.existsSync(node_path.join(candidate, packageName))) return candidate;
+        const parent = node_path.dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const collectRuntimePackageModuleDirectories = (packageNames, registrarUrl)=>{
+    const registrarDirectory = node_path.dirname(fileURLToPath(registrarUrl));
+    const directories = [];
+    for (const packageName of packageNames){
+        const directory = findHostingModuleDirectory(packageName, registrarDirectory);
+        if (directory && !directories.includes(directory)) directories.push(directory);
+    }
+    return directories;
+};
+const appendModuleDirectories = (config, directories)=>{
+    if (0 === directories.length) return;
+    config.resolve ??= {};
+    const existing = config.resolve.modules ?? [
+        'node_modules'
+    ];
+    config.resolve.modules = [
+        ...existing,
+        ...directories.filter((directory)=>!existing.includes(directory))
+    ];
+};
+const createRuntimePackageResolutionPlugin = (directories)=>({
+        name: 'ultramodern:runtime-package-resolution',
+        setup (api) {
+            api.modifyRspackConfig({
+                order: 'post',
+                handler (config) {
+                    appendModuleDirectories(config, directories);
+                }
+            });
+            api.onBeforeCreateCompiler({
+                order: 'post',
+                handler ({ bundlerConfigs }) {
+                    for (const config of bundlerConfigs)appendModuleDirectories(config, directories);
+                }
+            });
+        }
+    });
+const canResolveRuntimePackage = (packageName, registrarUrl)=>{
+    try {
+        createRequire(registrarUrl).resolve(packageName);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+export { canResolveRuntimePackage, collectRuntimePackageModuleDirectories, createRuntimePackageResolutionPlugin, findHostingModuleDirectory };

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

@@ -0,0 +1,206 @@
+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/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-node/backend-federation-build/config.mjs

@@ -0,0 +1,117 @@
+import "node:module";
+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_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 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
+        };
+    }
+    throw new Error(`[backend-federation-build] Missing delivery-unit build artifact at ${buildArtifactPath}.`);
+};
+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, createAppFromCompactMetadata, createStampedDeliveryUnit, findBackendFederationApp, findWorkspaceRoot, normalizeRelativePath, readBuildIdentity, resolveWorkspaceSourceRevision };

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

@@ -0,0 +1,100 @@
+import "node:module";
+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, 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 = buildArtifactPathFor(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-node/backend-federation-build/index.mjs

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