@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.1 → 3.5.0-ultramodern.100

package/dist/cjs/plugins/analyze/getServerRoutes.js

@@ -37,6 +37,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    getProdEntrypoints: ()=>getProdEntrypoints,
     getProdServerRoutes: ()=>getProdServerRoutes,
     getServerRoutes: ()=>getServerRoutes
 });
@@ -170,9 +171,27 @@ const getProdServerRoutes = (distDirectory)=>{
         throw new Error(`Failed to read routes from ${routeJSON}, please check if the file exists.`);
     }
 };
+const getProdEntrypoints = (distDirectory, routes, mainEntryName = MAIN_ENTRY_NAME)=>{
+    const byEntryName = new Map();
+    for (const route of routes){
+        if (!route.entryName || byEntryName.has(route.entryName)) continue;
+        const builtEntry = route.bundle || route.entryPath;
+        byEntryName.set(route.entryName, {
+            entryName: route.entryName,
+            entry: external_path_default().resolve(distDirectory, builtEntry),
+            isAutoMount: true,
+            isMainEntry: route.entryName === mainEntryName
+        });
+    }
+    return [
+        ...byEntryName.values()
+    ];
+};
+exports.getProdEntrypoints = __webpack_exports__.getProdEntrypoints;
 exports.getProdServerRoutes = __webpack_exports__.getProdServerRoutes;
 exports.getServerRoutes = __webpack_exports__.getServerRoutes;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getProdEntrypoints",
     "getProdServerRoutes",
     "getServerRoutes"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/plugins/analyze/index.js

@@ -55,10 +55,10 @@ const analyze = ()=>({
                 const resolvedConfig = api.getNormalizedConfig();
                 const hooks = api.getHooks();
                 try {
-                    if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)()) utils_namespaceObject.fs.emptydirSync(appContext.internalDirectory);
+                    if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)(appContext.command)) utils_namespaceObject.fs.emptydirSync(appContext.internalDirectory);
                 } catch  {}
                 const apiOnly = await (0, utils_namespaceObject.isApiOnly)(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
-                const [{ getProdServerRoutes }] = await Promise.all([
+                const [{ getProdEntrypoints, getProdServerRoutes }] = await Promise.all([
                     import("./getServerRoutes.js")
                 ]);
                 if (apiOnly) {
@@ -77,6 +77,17 @@ const analyze = ()=>({
                     });
                     return;
                 }
+                if ((0, external_utils_js_namespaceObject.checkIsServeCommand)()) {
+                    const routes = getProdServerRoutes(appContext.distDirectory);
+                    const entrypoints = getProdEntrypoints(appContext.distDirectory, routes, resolvedConfig.source.mainEntryName);
+                    api.updateAppContext({
+                        apiOnly,
+                        checkedEntries: entrypoints.map((entrypoint)=>entrypoint.entryName),
+                        entrypoints,
+                        serverRoutes: routes
+                    });
+                    return;
+                }
                 const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
                     import("./getBundleEntry.js"),
                     import("./getServerRoutes.js"),
@@ -87,17 +98,14 @@ const analyze = ()=>({
                 });
                 debug("entrypoints: %o", entrypoints);
                 const routes = [];
-                if ((0, external_utils_js_namespaceObject.checkIsServeCommand)()) routes.push(...getProdServerRoutes(appContext.distDirectory));
-                else {
-                    const initialRoutes = getServerRoutes(entrypoints, {
-                        appContext,
-                        config: resolvedConfig
-                    });
-                    const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
-                        routes: initialRoutes
-                    });
-                    routes.push(...modifiedRoutes);
-                }
+                const initialRoutes = getServerRoutes(entrypoints, {
+                    appContext,
+                    config: resolvedConfig
+                });
+                const { routes: modifiedRoutes } = await hooks.modifyServerRoutes.call({
+                    routes: initialRoutes
+                });
+                routes.push(...modifiedRoutes);
                 debug("server routes: %o", routes);
                 appContext = {
                     ...api.getAppContext(),
@@ -149,7 +157,7 @@ const analyze = ()=>({
                     htmlTemplates
                 };
                 api.updateAppContext(appContext);
-                if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)()) {
+                if ((0, external_utils_js_namespaceObject.checkIsBuildCommands)(appContext.command)) {
                     await hooks.generateEntryCode.call({
                         entrypoints
                     });

package/dist/cjs/plugins/analyze/utils.js

@@ -87,7 +87,7 @@ const parseModule = async ({ source, filename })=>{
     return await (0, external_es_module_lexer_namespaceObject.parse)(content);
 };
 const getServerCombinedModuleFile = (internalDirectory, entryName)=>external_path_default().join(internalDirectory, entryName, 'server-loader-combined.js');
-const checkIsBuildCommands = ()=>{
+const checkIsBuildCommands = (contextCommand)=>{
     const buildCommands = [
         'dev',
         'start',
@@ -97,7 +97,8 @@ const checkIsBuildCommands = ()=>{
         'dev-worker'
     ];
     const command = (0, utils_namespaceObject.getCommand)();
-    return buildCommands.includes(command);
+    if (buildCommands.includes(command)) return true;
+    return 'dev' === contextCommand || 'start' === contextCommand || 'build' === contextCommand || 'deploy' === contextCommand;
 };
 const checkIsServeCommand = ()=>{
     const command = (0, utils_namespaceObject.getCommand)();

package/dist/cjs/plugins/backend-federation/codegen.js

@@ -0,0 +1,255 @@
+"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__, {
+    createBackendManifest: ()=>createBackendManifest,
+    createBackendRemoteEntrySource: ()=>createBackendRemoteEntrySource
+});
+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 external_esbuild_namespaceObject = require("esbuild");
+const external_config_js_namespaceObject = require("./config.js");
+const createRelativeImportSpecifier = (fromDirectory, toFile)=>{
+    const relativePath = (0, external_config_js_namespaceObject.normalizeRelativePath)(external_node_path_default().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(external_node_path_default().dirname(effectApiPath), effectApiPath);
+    const containerMetadata = {
+        buildVersion: app.buildVersion,
+        expose: universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+        name: app.backendName,
+        packageName: app.packageName,
+        remoteType: app.remoteType,
+        source: (0, external_config_js_namespaceObject.normalizeRelativePath)(external_node_path_default().relative(workspaceRoot, effectApiPath)),
+        version: app.version,
+        ...app.unitId ? {
+            unitId: app.unitId
+        } : {},
+        ...app.sourceRevision ? {
+            sourceRevision: app.sourceRevision
+        } : {}
+    };
+    const compatibility = {
+        build: app.buildVersion,
+        contractVersion: universal_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+        nodeAdapterVersion: universal_namespaceObject.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(universal_namespaceObject.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 (0, external_esbuild_namespaceObject.build)({
+        absWorkingDir: external_node_path_default().dirname(effectApiPath),
+        bundle: true,
+        format: 'cjs',
+        logLevel: 'silent',
+        platform: 'node',
+        stdin: {
+            contents: source,
+            loader: 'ts',
+            resolveDir: external_node_path_default().dirname(effectApiPath),
+            sourcefile: external_node_path_default().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)=>{
+    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: universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            globalName: app.backendName,
+            publicPath,
+            ssrRemoteEntry: {
+                name: universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+                path: '',
+                type: app.remoteType
+            },
+            ssrPublicPath: publicPath
+        },
+        entry: {
+            file: universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE,
+            path: (0, external_config_js_namespaceObject.normalizeRelativePath)(external_node_path_default().relative(workspaceRoot, external_node_path_default().join(distDirectory, universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE))),
+            type: app.remoteType,
+            url: app.containerEntry
+        },
+        exposes: [
+            {
+                id: `${app.backendName}:${universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE}`,
+                name: universal_namespaceObject.BACKEND_FEDERATION_EFFECT_EXPOSE,
+                path: '',
+                assets: {
+                    js: {
+                        async: [],
+                        sync: [
+                            universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE
+                        ]
+                    },
+                    css: {
+                        async: [],
+                        sync: []
+                    }
+                }
+            }
+        ],
+        shared: [],
+        backendFederation: {
+            role: 'microvertical-server',
+            appId: app.id,
+            name: app.backendName,
+            runtimeFramework: 'effect',
+            strictEffectApproach: true,
+            contractVersion: universal_namespaceObject.BACKEND_FEDERATION_CONTRACT_VERSION,
+            nodeAdapterVersion: universal_namespaceObject.BACKEND_FEDERATION_NODE_ADAPTER_VERSION,
+            remoteType: app.remoteType,
+            expose: universal_namespaceObject.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 = (0, universal_namespaceObject.validateBackendFederationManifest)(manifest, {
+        path: 'backendFederationManifest',
+        requireEffectExpose: true,
+        requireEffectRuntime: true,
+        requireVersionFields: true
+    });
+    if (!validation.ok) throw new Error(`[backend-federation-build] Invalid backend federation manifest: ${(0, universal_namespaceObject.formatBackendFederationValidationErrors)(validation.errors)}.`);
+    return manifest;
+};
+exports.createBackendManifest = __webpack_exports__.createBackendManifest;
+exports.createBackendRemoteEntrySource = __webpack_exports__.createBackendRemoteEntrySource;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBackendManifest",
+    "createBackendRemoteEntrySource"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/plugins/backend-federation/config.js

@@ -0,0 +1,204 @@
+"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__, {
+    COMPACT_CONFIG_PATH: ()=>COMPACT_CONFIG_PATH,
+    buildArtifactPathFor: ()=>buildArtifactPathFor,
+    buildModulePathFor: ()=>buildModulePathFor,
+    createAppFromCompactMetadata: ()=>createAppFromCompactMetadata,
+    createStampedDeliveryUnit: ()=>createStampedDeliveryUnit,
+    findBackendFederationApp: ()=>findBackendFederationApp,
+    findWorkspaceRoot: ()=>findWorkspaceRoot,
+    normalizeRelativePath: ()=>normalizeRelativePath,
+    readBuildIdentity: ()=>readBuildIdentity,
+    resolveWorkspaceSourceRevision: ()=>resolveWorkspaceSourceRevision
+});
+const external_node_fs_namespaceObject = require("node:fs");
+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 external_ultramodern_release_identity_js_namespaceObject = require("../../ultramodern-release-identity.js");
+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_default().readFile(filePath, 'utf8'));
+const buildArtifactPathFor = (appDirectory)=>external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_PATH);
+const buildModulePathFor = (appDirectory)=>external_node_path_default().join(appDirectory, universal_namespaceObject.ULTRAMODERN_BUILD_MODULE_PATH);
+const readBuildIdentity = async (appDirectory)=>{
+    const buildArtifactPath = buildArtifactPathFor(appDirectory);
+    if ((0, external_node_fs_namespaceObject.existsSync)(buildArtifactPath)) {
+        const artifact = await readJsonFile(buildArtifactPath);
+        const artifactValidation = (0, universal_namespaceObject.validateUltramodernBuildArtifact)(artifact, buildArtifactPath);
+        if (!artifactValidation.ok) throw new Error(`[backend-federation-build] Invalid delivery-unit build artifact at ${buildArtifactPath}.`);
+        if (!(0, universal_namespaceObject.isUltramodernBuildArtifact)(artifact)) throw new Error(`[backend-federation-build] Invalid delivery-unit build artifact at ${buildArtifactPath}.`);
+        const deliveryUnit = artifact.deliveryUnit;
+        return {
+            artifact,
+            appId: deliveryUnit.appId,
+            buildVersion: deliveryUnit.buildMarker,
+            packageName: deliveryUnit.packageName,
+            version: deliveryUnit.version,
+            unitId: deliveryUnit.unitId,
+            sourceRevision: deliveryUnit.sourceRevision
+        };
+    }
+    const buildModulePath = buildModulePathFor(appDirectory);
+    if (!(0, external_node_fs_namespaceObject.existsSync)(buildModulePath)) return {};
+    console.warn(`[backend-federation-build] ${buildArtifactPath} missing; falling back to legacy regex parsing of ${buildModulePath}. Regenerate the workspace to emit ${universal_namespaceObject.ULTRAMODERN_BUILD_ARTIFACT_FILE}.`);
+    const source = await promises_default().readFile(buildModulePath, 'utf8');
+    return {
+        appId: source.match(/\bappId:\s*['"]([^'"]+)['"]/u)?.[1],
+        buildVersion: source.match(/\bbuild:\s*['"]([^'"]+)['"]/u)?.[1],
+        packageName: source.match(/\bpackageName:\s*['"]([^'"]+)['"]/u)?.[1],
+        version: source.match(/\bversion:\s*['"]([^'"]+)['"]/u)?.[1],
+        unitId: source.match(/\bunitId:\s*['"]([^'"]+)['"]/u)?.[1],
+        sourceRevision: source.match(/\bsourceRevision:\s*['"]([^'"]+)['"]/u)?.[1]
+    };
+};
+const toPascalCase = (value)=>value.split(/[^a-zA-Z0-9]+/u).filter(Boolean).map((part)=>part.charAt(0).toUpperCase() + part.slice(1)).join('');
+const stringValue = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+const createBackendName = (app, id)=>{
+    const configuredName = stringValue(app.backendFederation?.name) ?? stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName) ?? stringValue(app.serverExecution?.node?.remoteName);
+    if (configuredName) return configuredName;
+    const mfName = stringValue(app.moduleFederation?.name);
+    return mfName ? `${mfName}Backend` : `vertical${toPascalCase(id)}Backend`;
+};
+const findWorkspaceRoot = (appDirectory)=>{
+    let current = appDirectory;
+    while(true){
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_node_path_default().join(current, COMPACT_CONFIG_PATH))) return current;
+        const parent = external_node_path_default().dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+};
+const resolveWorkspaceSourceRevision = async (workspaceRoot)=>(0, external_ultramodern_release_identity_js_namespaceObject.resolveUltramodernSourceRevision)(workspaceRoot);
+const createStampedDeliveryUnit = (input)=>{
+    if (!input.unitId || !input.buildMarker || !input.packageName || !input.version) return;
+    const record = {
+        schemaVersion: universal_namespaceObject.DELIVERY_UNIT_SCHEMA_VERSION,
+        kind: universal_namespaceObject.DELIVERY_UNIT_KIND,
+        appId: input.appId,
+        unitId: input.unitId,
+        packageName: input.packageName,
+        version: input.version,
+        buildMarker: input.buildMarker,
+        sourceRevision: input.sourceRevision,
+        deployProfile: universal_namespaceObject.DELIVERY_UNIT_DEPLOY_PROFILE
+    };
+    const validation = (0, universal_namespaceObject.validateDeliveryUnitRecord)(record);
+    if (!validation.ok) return;
+    return (0, universal_namespaceObject.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 (external_node_path_default().resolve(workspaceRoot, directory) !== external_node_path_default().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}/${universal_namespaceObject.BACKEND_FEDERATION_MANIFEST_FILE}`;
+    const containerEntry = stringValue(compactApp.backendFederation?.executionSurfaces?.node?.containerEntry) ?? stringValue(compactApp.serverExecution?.node?.containerEntry) ?? `http://localhost:${port}/${universal_namespaceObject.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(`/${universal_namespaceObject.BACKEND_FEDERATION_REMOTE_ENTRY_FILE}`)) throw new Error(`[backend-federation-build] Node backend federation containerEntry must end with "/${universal_namespaceObject.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 = external_node_path_default().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;
+    }
+};
+exports.COMPACT_CONFIG_PATH = __webpack_exports__.COMPACT_CONFIG_PATH;
+exports.buildArtifactPathFor = __webpack_exports__.buildArtifactPathFor;
+exports.buildModulePathFor = __webpack_exports__.buildModulePathFor;
+exports.createAppFromCompactMetadata = __webpack_exports__.createAppFromCompactMetadata;
+exports.createStampedDeliveryUnit = __webpack_exports__.createStampedDeliveryUnit;
+exports.findBackendFederationApp = __webpack_exports__.findBackendFederationApp;
+exports.findWorkspaceRoot = __webpack_exports__.findWorkspaceRoot;
+exports.normalizeRelativePath = __webpack_exports__.normalizeRelativePath;
+exports.readBuildIdentity = __webpack_exports__.readBuildIdentity;
+exports.resolveWorkspaceSourceRevision = __webpack_exports__.resolveWorkspaceSourceRevision;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "COMPACT_CONFIG_PATH",
+    "buildArtifactPathFor",
+    "buildModulePathFor",
+    "createAppFromCompactMetadata",
+    "createStampedDeliveryUnit",
+    "findBackendFederationApp",
+    "findWorkspaceRoot",
+    "normalizeRelativePath",
+    "readBuildIdentity",
+    "resolveWorkspaceSourceRevision"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});