@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.1 → 3.9.0-ultramodern.11

package/dist/cjs/policy-defaults.js

@@ -0,0 +1,101 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+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__, {
+    POLICY_DEFAULTS_PLUGIN_NAME: ()=>POLICY_DEFAULTS_PLUGIN_NAME,
+    RENDERER_EXTENSIONS_PACKAGE: ()=>RENDERER_EXTENSIONS_PACKAGE,
+    RENDERER_EXTENSIONS_PLUGIN_NAME: ()=>RENDERER_EXTENSIONS_PLUGIN_NAME,
+    SERVER_EXTENSIONS_PLUGIN_NAME: ()=>SERVER_EXTENSIONS_PLUGIN_NAME,
+    applyPolicyDefaults: ()=>applyPolicyDefaults,
+    createPolicyDefaultsPlugin: ()=>createPolicyDefaultsPlugin
+});
+const external_runtime_package_resolution_js_namespaceObject = require("./runtime-package-resolution.js");
+const RENDERER_EXTENSIONS_PACKAGE = '@modern-js/runtime-renderer-extensions';
+const RENDERER_EXTENSIONS_PLUGIN_NAME = 'rendererHead';
+const SERVER_EXTENSIONS_PLUGIN_NAME = '@modern-js/app-tools/server-plugin';
+const POLICY_DEFAULTS_PLUGIN_NAME = '@modern-js/ultramodern-policy-defaults';
+const applyPolicyDefaults = (api, options = {})=>{
+    if (false !== options.rendererExtensions) {
+        api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+            if (!plugins.some((plugin)=>plugin.path === RENDERER_EXTENSIONS_PACKAGE)) plugins.push({
+                name: RENDERER_EXTENSIONS_PLUGIN_NAME,
+                path: RENDERER_EXTENSIONS_PACKAGE,
+                config: {}
+            });
+            return {
+                entrypoint,
+                plugins
+            };
+        });
+        const moduleDirectories = (0, external_runtime_package_resolution_js_namespaceObject.collectRuntimePackageModuleDirectories)([
+            RENDERER_EXTENSIONS_PACKAGE
+        ], __rslib_import_meta_url__);
+        if (moduleDirectories.length > 0) api.modifyResolvedConfig((config)=>({
+                ...config,
+                builderPlugins: [
+                    ...config.builderPlugins ?? [],
+                    (0, external_runtime_package_resolution_js_namespaceObject.createRuntimePackageResolutionPlugin)(moduleDirectories)
+                ]
+            }));
+    }
+    if (false !== options.serverExtensions) api._internalServerPlugins(({ plugins })=>{
+        if (!plugins.some((plugin)=>plugin.name === SERVER_EXTENSIONS_PLUGIN_NAME)) plugins.push({
+            name: SERVER_EXTENSIONS_PLUGIN_NAME
+        });
+        return {
+            plugins
+        };
+    });
+};
+const createPolicyDefaultsPlugin = (options = {})=>({
+        name: POLICY_DEFAULTS_PLUGIN_NAME,
+        setup (api) {
+            applyPolicyDefaults(api, options);
+        }
+    });
+exports.POLICY_DEFAULTS_PLUGIN_NAME = __webpack_exports__.POLICY_DEFAULTS_PLUGIN_NAME;
+exports.RENDERER_EXTENSIONS_PACKAGE = __webpack_exports__.RENDERER_EXTENSIONS_PACKAGE;
+exports.RENDERER_EXTENSIONS_PLUGIN_NAME = __webpack_exports__.RENDERER_EXTENSIONS_PLUGIN_NAME;
+exports.SERVER_EXTENSIONS_PLUGIN_NAME = __webpack_exports__.SERVER_EXTENSIONS_PLUGIN_NAME;
+exports.applyPolicyDefaults = __webpack_exports__.applyPolicyDefaults;
+exports.createPolicyDefaultsPlugin = __webpack_exports__.createPolicyDefaultsPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "POLICY_DEFAULTS_PLUGIN_NAME",
+    "RENDERER_EXTENSIONS_PACKAGE",
+    "RENDERER_EXTENSIONS_PLUGIN_NAME",
+    "SERVER_EXTENSIONS_PLUGIN_NAME",
+    "applyPolicyDefaults",
+    "createPolicyDefaultsPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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';
@@ -73,6 +73,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 = external_node_path_default().posix.dirname(manifestLogicalPath);
+    const routesManifest = await readJson(external_node_path_default().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 = external_node_path_default().posix.join(directory, relative);
+            if (!files.includes(logicalPath)) return [];
+            const assetStat = await promises_default().lstat(external_node_path_default().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(external_node_path_default().join(distDirectory, manifestLogicalPath));
     const references = [
@@ -82,9 +122,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(external_node_path_default().join(distDirectory, routeSpecLogicalPath));
@@ -134,11 +175,14 @@ const writeReleaseEnvelope = async (artifactRoot, envelope)=>{
     if (!envelopePath) throw new Error('[ultramodern-release-envelope] could not resolve release envelope path.');
     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 readBuildArtifact = async (distDirectory, requirePromotable = true)=>{
+    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 ('workspace' === artifact.deliveryUnit.sourceRevision) throw new Error('[ultramodern-release-envelope] sourceRevision "workspace" cannot produce a promotable full-stack envelope.');
+    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) {
+        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)=>{
@@ -154,7 +198,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;
@@ -283,10 +327,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: [
@@ -299,8 +343,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 = [
@@ -309,8 +353,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([
@@ -336,17 +380,18 @@ 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 = 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)
     ]);
     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,
@@ -387,9 +432,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({
@@ -410,12 +455,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];
@@ -454,13 +499,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([
@@ -488,8 +533,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
             }
         }
     };
@@ -525,8 +570,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,24 +52,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 (0, external_framework_output_js_namespaceObject.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/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/cjs/runtime-package-resolution.js

@@ -0,0 +1,118 @@
+"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__, {
+    canResolveRuntimePackage: ()=>canResolveRuntimePackage,
+    collectRuntimePackageModuleDirectories: ()=>collectRuntimePackageModuleDirectories,
+    createRuntimePackageResolutionPlugin: ()=>createRuntimePackageResolutionPlugin,
+    findHostingModuleDirectory: ()=>findHostingModuleDirectory
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+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_node_url_namespaceObject = require("node:url");
+const findHostingModuleDirectory = (packageName, fromDirectory)=>{
+    let directory = external_node_path_default().resolve(fromDirectory);
+    for(;;){
+        const candidate = external_node_path_default().join(directory, 'node_modules');
+        if (external_node_fs_default().existsSync(external_node_path_default().join(candidate, packageName))) return candidate;
+        const parent = external_node_path_default().dirname(directory);
+        if (parent === directory) return;
+        directory = parent;
+    }
+};
+const collectRuntimePackageModuleDirectories = (packageNames, registrarUrl)=>{
+    const registrarDirectory = external_node_path_default().dirname((0, external_node_url_namespaceObject.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 {
+        (0, external_node_module_namespaceObject.createRequire)(registrarUrl).resolve(packageName);
+        return true;
+    } catch  {
+        return false;
+    }
+};
+exports.canResolveRuntimePackage = __webpack_exports__.canResolveRuntimePackage;
+exports.collectRuntimePackageModuleDirectories = __webpack_exports__.collectRuntimePackageModuleDirectories;
+exports.createRuntimePackageResolutionPlugin = __webpack_exports__.createRuntimePackageResolutionPlugin;
+exports.findHostingModuleDirectory = __webpack_exports__.findHostingModuleDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "canResolveRuntimePackage",
+    "collectRuntimePackageModuleDirectories",
+    "createRuntimePackageResolutionPlugin",
+    "findHostingModuleDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});