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

package/dist/cjs/deploy-output/npmAliases.js

@@ -0,0 +1,226 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    preserveNpmAliases: ()=>preserveNpmAliases,
+    readPackageIdentity: ()=>readPackageIdentity
+});
+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 dependencyKeys = [
+    'dependencies',
+    'optionalDependencies'
+];
+const exactVersionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
+async function readPackageJson(filePath) {
+    return JSON.parse(await promises_default().readFile(filePath, 'utf8'));
+}
+function parseNpmAlias(aliasName, specifier) {
+    if (!specifier.startsWith('npm:')) return;
+    const target = specifier.slice(4);
+    const versionSeparator = target.lastIndexOf('@');
+    if (versionSeparator <= 0 || versionSeparator === target.length - 1) throw new Error(`Invalid npm alias specifier for ${aliasName}: ${specifier}`);
+    return {
+        aliasName,
+        targetName: target.slice(0, versionSeparator),
+        targetVersion: target.slice(versionSeparator + 1)
+    };
+}
+function aliasesFromPackageJson(packageJson) {
+    const aliases = [];
+    for (const dependencyKey of dependencyKeys)for (const [aliasName, specifier] of Object.entries(packageJson[dependencyKey] ?? {})){
+        const alias = parseNpmAlias(aliasName, specifier);
+        if (alias) aliases.push(alias);
+    }
+    return aliases;
+}
+async function collectPackageRecords(nodeModulesDirectory) {
+    const records = [];
+    const visitedNodeModules = new Set();
+    const visitPackage = async (directory)=>{
+        const packageJsonPath = external_node_path_default().join(directory, 'package.json');
+        try {
+            const packageJson = await readPackageJson(packageJsonPath);
+            if (packageJson.name && packageJson.version) records.push({
+                directory,
+                packageJson
+            });
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        await visitNodeModules(external_node_path_default().join(directory, 'node_modules'));
+    };
+    const visitScope = async (scopeDirectory)=>{
+        const entries = await promises_default().readdir(scopeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) await visitPackage(external_node_path_default().join(scopeDirectory, entry.name));
+    };
+    const visitNdepeStore = async (storeDirectory)=>{
+        const entries = await promises_default().readdir(storeDirectory, {
+            withFileTypes: true
+        });
+        for (const entry of entries)if (entry.isDirectory()) {
+            const entryPath = external_node_path_default().join(storeDirectory, entry.name);
+            if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitNodeModules(external_node_path_default().join(entryPath, 'node_modules'));
+        }
+    };
+    const visitNodeModules = async (directory)=>{
+        const resolvedDirectory = external_node_path_default().resolve(directory);
+        if (visitedNodeModules.has(resolvedDirectory)) return;
+        visitedNodeModules.add(resolvedDirectory);
+        let entries;
+        try {
+            entries = await promises_default().readdir(directory, {
+                withFileTypes: true
+            });
+        } catch (error) {
+            if ('ENOENT' === error.code) return;
+            throw error;
+        }
+        for (const entry of entries){
+            if (!entry.isDirectory()) continue;
+            const entryPath = external_node_path_default().join(directory, entry.name);
+            if ('.ndepe' === entry.name) await visitNdepeStore(entryPath);
+            else if (entry.name.startsWith('@')) await visitScope(entryPath);
+            else await visitPackage(entryPath);
+        }
+    };
+    await visitNodeModules(nodeModulesDirectory);
+    return records;
+}
+async function resolveAliasTarget(ownerDirectory, alias, outputDirectory) {
+    let directory = ownerDirectory;
+    const outputRoot = external_node_path_default().resolve(outputDirectory);
+    const resolvedOutputRoot = await promises_default().realpath(outputRoot);
+    while(directory === outputRoot || directory.startsWith(`${outputRoot}${external_node_path_default().sep}`)){
+        const candidate = external_node_path_default().join(directory, 'node_modules', alias.targetName);
+        try {
+            const resolvedCandidate = await promises_default().realpath(candidate);
+            if (resolvedCandidate !== resolvedOutputRoot && !resolvedCandidate.startsWith(`${resolvedOutputRoot}${external_node_path_default().sep}`)) throw new Error(`Cannot preserve npm alias ${alias.aliasName}: emitted target ${candidate} resolves outside deployment output to ${resolvedCandidate}`);
+            const packageJson = await readPackageJson(external_node_path_default().join(candidate, 'package.json'));
+            if (packageJson.name !== alias.targetName || !packageJson.version) throw new Error(`npm alias ${alias.aliasName} resolved ${candidate} to unexpected package ${String(packageJson.name)}`);
+            if (exactVersionPattern.test(alias.targetVersion) && packageJson.version !== alias.targetVersion) return;
+            return {
+                directory: candidate,
+                packageJson
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        if (directory === outputRoot) break;
+        directory = external_node_path_default().dirname(directory);
+    }
+}
+async function ensureAliasLink(ownerDirectory, alias, target) {
+    const aliasPath = external_node_path_default().join(ownerDirectory, 'node_modules', alias.aliasName);
+    await promises_default().mkdir(external_node_path_default().dirname(aliasPath), {
+        recursive: true
+    });
+    try {
+        const [existing, expected] = await Promise.all([
+            promises_default().realpath(aliasPath),
+            promises_default().realpath(target.directory)
+        ]);
+        if (existing === expected) return;
+        throw new Error(`Cannot preserve npm alias ${alias.aliasName}: ${aliasPath} already resolves to ${existing}, expected ${expected}`);
+    } catch (error) {
+        if ('ENOENT' !== error.code) throw error;
+    }
+    const linkTarget = external_node_path_default().relative(external_node_path_default().dirname(aliasPath), target.directory);
+    await promises_default().symlink(linkTarget, aliasPath, 'dir');
+}
+function aliasSpecifier(alias) {
+    return `npm:${alias.targetName}@${alias.targetVersion}`;
+}
+async function readPackageIdentity(entryPath) {
+    let directory = external_node_path_default().dirname(entryPath);
+    const root = external_node_path_default().parse(directory).root;
+    while(directory !== root){
+        try {
+            const packageJson = await readPackageJson(external_node_path_default().join(directory, 'package.json'));
+            if (packageJson.name && packageJson.version) return {
+                name: packageJson.name,
+                version: packageJson.version
+            };
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        directory = external_node_path_default().dirname(directory);
+    }
+    throw new Error(`Cannot find owning package for deployment entry ${entryPath}`);
+}
+async function preserveNpmAliases({ appDirectory, outputDirectory, implicitAliases = [] }) {
+    const records = await collectPackageRecords(external_node_path_default().join(outputDirectory, 'node_modules'));
+    const appPackageJson = await readPackageJson(external_node_path_default().join(appDirectory, 'package.json'));
+    const rootAliases = [
+        ...aliasesFromPackageJson(appPackageJson),
+        ...implicitAliases
+    ].filter((alias)=>alias.aliasName !== alias.targetName);
+    const emittedRootAliases = [];
+    for (const alias of rootAliases){
+        const target = await resolveAliasTarget(outputDirectory, alias, outputDirectory);
+        if (!target) {
+            if (implicitAliases.includes(alias)) throw new Error(`Cannot preserve implicit npm alias ${alias.aliasName}: emitted target ${alias.targetName}@${alias.targetVersion} is missing`);
+            continue;
+        }
+        await ensureAliasLink(outputDirectory, alias, target);
+        emittedRootAliases.push(alias);
+    }
+    for (const record of records)for (const alias of aliasesFromPackageJson(record.packageJson).filter((candidate)=>candidate.aliasName !== candidate.targetName)){
+        const target = await resolveAliasTarget(record.directory, alias, outputDirectory);
+        if (target) await ensureAliasLink(record.directory, alias, target);
+    }
+    const outputPackageJsonPath = external_node_path_default().join(outputDirectory, 'package.json');
+    const outputPackageJson = await readPackageJson(outputPackageJsonPath);
+    outputPackageJson.dependencies ??= {};
+    for (const alias of emittedRootAliases)outputPackageJson.dependencies[alias.aliasName] = aliasSpecifier(alias);
+    await promises_default().writeFile(outputPackageJsonPath, `${JSON.stringify(outputPackageJson, null, 2)}\n`);
+}
+exports.preserveNpmAliases = __webpack_exports__.preserveNpmAliases;
+exports.readPackageIdentity = __webpack_exports__.readPackageIdentity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "preserveNpmAliases",
+    "readPackageIdentity"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/deploy-output/plugin.js

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createDeployOutputAliasesPlugin: ()=>createDeployOutputAliasesPlugin
+});
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_npmAliases_js_namespaceObject = require("./npmAliases.js");
+const external_target_js_namespaceObject = require("./target.js");
+const createDeployOutputAliasesPlugin = ({ resolveDeployTarget = external_target_js_namespaceObject.resolveDeployTarget } = {})=>({
+        name: '@modern-js/deploy-output-aliases',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const { appDirectory, metaName } = api.getAppContext();
+                const config = api.getNormalizedConfig();
+                if ('modern-js' !== metaName && !config.deploy?.target && !process.env.MODERNJS_DEPLOY || 'node' !== resolveDeployTarget(config)) return;
+                const entry = (0, external_node_module_namespaceObject.createRequire)(__filename).resolve('@modern-js/prod-server');
+                const identity = await (0, external_npmAliases_js_namespaceObject.readPackageIdentity)(entry);
+                await (0, external_npmAliases_js_namespaceObject.preserveNpmAliases)({
+                    appDirectory,
+                    outputDirectory: external_node_path_default().join(appDirectory, '.output'),
+                    implicitAliases: [
+                        {
+                            aliasName: '@modern-js/prod-server',
+                            targetName: identity.name,
+                            targetVersion: identity.version
+                        }
+                    ]
+                });
+            });
+        }
+    });
+exports.createDeployOutputAliasesPlugin = __webpack_exports__.createDeployOutputAliasesPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDeployOutputAliasesPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/deploy-output/target.js

@@ -0,0 +1,48 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveDeployTarget: ()=>resolveDeployTarget
+});
+const external_std_env_namespaceObject = require("std-env");
+const providerDeployTargets = {
+    vercel: 'vercel',
+    netlify: 'netlify',
+    cloudflare: 'cloudflare',
+    cloudflare_pages: 'cloudflare',
+    cloudflare_workers: 'cloudflare'
+};
+const resolveDeployTarget = (config, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = external_std_env_namespaceObject.provider)=>config.deploy?.target || envDeployTarget || (detectedProvider ? providerDeployTargets[detectedProvider] : void 0) || 'node';
+exports.resolveDeployTarget = __webpack_exports__.resolveDeployTarget;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveDeployTarget"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/native-type-checker.js

@@ -41,11 +41,13 @@ __webpack_require__.d(__webpack_exports__, {
     configureUltramodernTypeChecker: ()=>configureUltramodernTypeChecker
 });
 const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const external_node_util_namespaceObject = require("node:util");
 const execute = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
 const native_type_checker_name = 'UltramodernNativeTypeChecker';
+const watchDependencyPath = (file)=>'win32' === process.platform ? external_node_fs_namespaceObject.realpathSync.native(file) : file;
 class UltramodernNativeTypeChecker {
     async check() {
         const { configFile, build } = this.options;
@@ -73,7 +75,8 @@ class UltramodernNativeTypeChecker {
             return result.stdout;
         } catch (cause) {
             const output = cause;
-            throw new Error(`${native_type_checker_name} failed:\n${output.stdout ?? ''}${output.stderr ?? ''}`, {
+            const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`, {
                 cause
             });
         }
@@ -104,10 +107,10 @@ class UltramodernNativeTypeChecker {
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
-            compilation.fileDependencies.add(this.options.configFile);
             compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
                 try {
-                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(file);
+                    compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
+                    for (const file of (await this.watchInputs()))compilation.fileDependencies.add(watchDependencyPath(file));
                     await this.check();
                 } catch (cause) {
                     compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {

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'