@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/dist/esm-node/builder/shared/lazyCompilation.mjs

@@ -21,7 +21,6 @@ function buildRouteEagerLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
-const buildSSRLazyCompilationTest = buildRouteEagerLazyCompilationTest;
 function planRouteEagerLazyCompilation(current, info) {
     if (!current) return {
         apply: false
@@ -43,5 +42,4 @@ function planRouteEagerLazyCompilation(current, info) {
         }
     };
 }
-const planSSRLazyCompilation = planRouteEagerLazyCompilation;
-export { aggregateEagerRouteComponentFiles, buildRouteEagerLazyCompilationTest, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planRouteEagerLazyCompilation, planSSRLazyCompilation };
+export { aggregateEagerRouteComponentFiles, buildRouteEagerLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planRouteEagerLazyCompilation };

package/dist/esm-node/commands/index.mjs

@@ -41,5 +41,4 @@ const infoCommand = (program, api)=>{
         await info(api, options);
     });
 };
-export { runtimeCommand } from "./runtime.mjs";
 export { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand };

package/dist/esm-node/config/build-environment.mjs

@@ -0,0 +1,225 @@
+import "node:module";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { accessSync, chmodSync, constants, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+const EFFECT_TSGO_PACKAGE = '@effect/tsgo';
+const EFFECT_TSGO_BIN = 'effect-tsgo';
+const EFFECT_TSGO_RESOLUTION_ERROR = 'Unable to resolve the Effect TS-Go compiler. Install "@effect/tsgo" and a native TypeScript backend for this build config, or set EFFECT_TSGO_BIN.';
+const executableEffectTsgoCompilers = new Map();
+const BUILD_CONFIG_ENVIRONMENT_PLUGIN = 'ModernJsBuildConfigEnvironmentLeasePlugin';
+const ENVIRONMENT_LEASE_REGISTRY_KEY = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry/v1');
+const ENVIRONMENT_LEASE_REGISTRY_BRAND = Symbol.for('@modern-js/app-tools/build-config-environment-lease-registry-brand/v1');
+const LIFECYCLE_HOOK_NAMES = [
+    'run',
+    'watchRun',
+    'afterDone',
+    'failed',
+    'shutdown',
+    'watchClose'
+];
+function restoreEnvironment(name, value) {
+    if (void 0 === value) delete process.env[name];
+    else process.env[name] = value;
+}
+function createEnvironmentLeaseRegistry() {
+    const environmentLeases = new Map();
+    return Object.freeze({
+        acquire (name, value) {
+            let lease = environmentLeases.get(name);
+            if (lease) {
+                if (lease.value !== value) throw new Error(`Build config environment "${name}" already has an active lease for a different value.`);
+                if (process.env[name] !== lease.value) throw new Error(`Build config environment lease for "${name}" lost ownership before another lease was acquired.`);
+            } else {
+                lease = {
+                    originalValue: process.env[name],
+                    owners: new Set(),
+                    value
+                };
+                process.env[name] = value;
+                environmentLeases.set(name, lease);
+            }
+            const owner = Symbol(name);
+            lease.owners.add(owner);
+            let released = false;
+            return ()=>{
+                if (released) return;
+                if (environmentLeases.get(name) !== lease || !lease.owners.has(owner)) throw new Error(`Build config environment lease for "${name}" cannot be restored because its ownership record was lost.`);
+                released = true;
+                const lostOwnership = process.env[name] !== lease.value;
+                lease.owners.delete(owner);
+                if (0 === lease.owners.size) {
+                    environmentLeases.delete(name);
+                    restoreEnvironment(name, lease.originalValue);
+                } else if (lostOwnership) process.env[name] = lease.value;
+                if (lostOwnership) throw new Error(`Build config environment lease for "${name}" lost ownership before restoration.`);
+            };
+        },
+        brand: ENVIRONMENT_LEASE_REGISTRY_BRAND
+    });
+}
+function getEnvironmentLeaseRegistry() {
+    const descriptor = Object.getOwnPropertyDescriptor(process, ENVIRONMENT_LEASE_REGISTRY_KEY);
+    if (descriptor) {
+        const registry = descriptor.value;
+        if (descriptor.configurable || descriptor.enumerable || descriptor.writable || registry?.brand !== ENVIRONMENT_LEASE_REGISTRY_BRAND || 'function' != typeof registry.acquire) throw new Error('The process-global build config environment lease registry is occupied by an incompatible value.');
+        return registry;
+    }
+    const registry = createEnvironmentLeaseRegistry();
+    Object.defineProperty(process, ENVIRONMENT_LEASE_REGISTRY_KEY, {
+        configurable: false,
+        enumerable: false,
+        value: registry,
+        writable: false
+    });
+    return registry;
+}
+function acquireEnvironmentLease(name, value) {
+    return getEnvironmentLeaseRegistry().acquire(name, value);
+}
+function releaseAfterFailure(release, originalError) {
+    try {
+        release();
+    } catch (restorationError) {
+        throw new AggregateError([
+            originalError,
+            restorationError
+        ], 'Build config environment setup and restoration both failed.');
+    }
+    throw originalError;
+}
+class BuildConfigEnvironmentLeasePlugin {
+    apply(compiler) {
+        const hooks = compiler.hooks;
+        try {
+            const lifecycleHooks = {};
+            for (const hookName of LIFECYCLE_HOOK_NAMES){
+                const hook = hooks[hookName];
+                if (!hook || 'function' != typeof hook.tap) throw new Error(`Rspack does not expose the "${hookName}" lifecycle hook required to restore build config environment leases.`);
+                lifecycleHooks[hookName] = hook;
+            }
+            let mode = 'pending';
+            const modeTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MIN_SAFE_INTEGER
+            };
+            const releaseTap = {
+                name: BUILD_CONFIG_ENVIRONMENT_PLUGIN,
+                stage: Number.MAX_SAFE_INTEGER
+            };
+            const releaseAfterOneShot = ()=>{
+                if ('watch' !== mode && true !== compiler.watchMode) this.release();
+            };
+            lifecycleHooks.run.tap(modeTap, ()=>{
+                mode = 'run';
+            });
+            lifecycleHooks.watchRun.tap(modeTap, ()=>{
+                mode = 'watch';
+            });
+            lifecycleHooks.afterDone.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.failed.tap(releaseTap, releaseAfterOneShot);
+            lifecycleHooks.shutdown.tap(releaseTap, this.release);
+            lifecycleHooks.watchClose.tap(releaseTap, this.release);
+        } catch (error) {
+            releaseAfterFailure(this.release, error);
+        }
+    }
+    constructor(release){
+        this.release = release;
+    }
+}
+function resolveEffectTsgoCli(from) {
+    const projectRequire = createRequire(from);
+    const packageJsonPath = projectRequire.resolve(`${EFFECT_TSGO_PACKAGE}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const bin = 'string' == typeof packageJson.bin ? packageJson.bin : packageJson.bin?.[EFFECT_TSGO_BIN];
+    if (!bin) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    return resolve(dirname(packageJsonPath), bin);
+}
+function resolveExecutableEffectTsgoCompiler(compilerPath) {
+    if ('win32' === process.platform) return compilerPath;
+    const sourcePath = realpathSync(compilerPath);
+    const source = lstatSync(sourcePath);
+    if (!source.isFile()) throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    try {
+        accessSync(sourcePath, constants.X_OK);
+        return compilerPath;
+    } catch  {}
+    const cachedCompiler = executableEffectTsgoCompilers.get(sourcePath);
+    if (cachedCompiler) try {
+        accessSync(cachedCompiler, constants.X_OK);
+        return cachedCompiler;
+    } catch  {
+        executableEffectTsgoCompilers.delete(sourcePath);
+    }
+    const compilerBytes = readFileSync(sourcePath);
+    const compilerDigest = createHash('sha256').update(compilerBytes).digest('hex');
+    const compilerDirectory = join(tmpdir(), 'modern-js', 'effect-tsgo', compilerDigest);
+    mkdirSync(compilerDirectory, {
+        recursive: true,
+        mode: 448
+    });
+    const executableCompiler = join(compilerDirectory, basename(sourcePath));
+    try {
+        accessSync(executableCompiler, constants.X_OK);
+    } catch  {
+        const temporaryCompiler = join(compilerDirectory, `.${basename(sourcePath)}.${process.pid}.tmp`);
+        rmSync(temporaryCompiler, {
+            force: true
+        });
+        try {
+            writeFileSync(temporaryCompiler, compilerBytes, {
+                flag: 'wx',
+                mode: 448
+            });
+            chmodSync(temporaryCompiler, 448);
+            renameSync(temporaryCompiler, executableCompiler);
+        } finally{
+            rmSync(temporaryCompiler, {
+                force: true
+            });
+        }
+    }
+    accessSync(executableCompiler, constants.X_OK);
+    executableEffectTsgoCompilers.set(sourcePath, executableCompiler);
+    return executableCompiler;
+}
+function getBuildConfigEnvironment(name) {
+    return process.env[name];
+}
+function withBuildConfigEnvironment(name, value, setup) {
+    return async (config, ...args)=>{
+        const release = acquireEnvironmentLease(name, value);
+        try {
+            const configured = await setup(config, ...args) ?? config;
+            configured.plugins = [
+                ...configured.plugins ?? [],
+                new BuildConfigEnvironmentLeasePlugin(release)
+            ];
+            return configured;
+        } catch (error) {
+            releaseAfterFailure(release, error);
+        }
+    };
+}
+function resolveEffectTsgoCompiler(options) {
+    const configuredCompiler = getBuildConfigEnvironment('EFFECT_TSGO_BIN')?.trim();
+    if (configuredCompiler) try {
+        return resolveExecutableEffectTsgoCompiler(configuredCompiler);
+    } catch  {
+        throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+    }
+    try {
+        const compiler = execFileSync(process.execPath, [
+            resolveEffectTsgoCli(options.from),
+            'get-exe-path'
+        ], {
+            encoding: 'utf-8'
+        }).trim();
+        if (compiler) return resolveExecutableEffectTsgoCompiler(compiler);
+    } catch  {}
+    throw new Error(EFFECT_TSGO_RESOLUTION_ERROR);
+}
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment };

package/dist/esm-node/config/index.mjs

@@ -1,3 +1,4 @@
 import "node:module";
+export * from "./build-environment.mjs";
 export * from "./default.mjs";
 export * from "./initialize/index.mjs";

package/dist/esm-node/config/public.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { getBuildConfigEnvironment, resolveEffectTsgoCompiler, withBuildConfigEnvironment } from "./build-environment.mjs";

package/dist/esm-node/index.mjs

@@ -5,22 +5,22 @@ import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
 import { createAsyncHook } from "@modern-js/plugin";
 import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
 import path from "path";
-import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, runtimeCommand, serverCommand } from "./commands/index.mjs";
+import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand } from "./commands/index.mjs";
 import { compatPlugin } from "./compat/index.mjs";
 import { DEFAULT_RUNTIME_CONFIG_FILE } from "./constants.mjs";
 import { i18n } from "./locale/index.mjs";
 import analyze from "./plugins/analyze/index.mjs";
+import backendFederationBuild from "./plugins/backendFederationBuild.mjs";
 import deploy from "./plugins/deploy/index.mjs";
 import initialize from "./plugins/initialize/index.mjs";
 import serverBuild from "./plugins/serverBuild.mjs";
 import serverRuntime from "./plugins/serverRuntime.mjs";
+import ultramodernReleaseEnvelope from "./plugins/ultramodernReleaseEnvelope.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
-export * from "./baseline.mjs";
 export * from "./defineConfig.mjs";
 export * from "./presetUltramodern.mjs";
-export * from "./ultramodern/designSystem.mjs";
 export * from "./types/index.mjs";
 const appTools = ()=>({
         name: '@modern-js/app-tools',
@@ -30,6 +30,8 @@ const appTools = ()=>({
             initialize(),
             analyze(),
             serverBuild(),
+            backendFederationBuild(),
+            ultramodernReleaseEnvelope(),
             deploy()
         ],
         post: [
@@ -74,7 +76,6 @@ const appTools = ()=>({
                 deployCommand(program, api);
                 inspectCommand(program, api);
                 infoCommand(program, api);
-                await runtimeCommand(program, api);
                 deprecatedCommands(program);
             });
             api.onPrepare(async ()=>{

package/dist/esm-node/plugins/analyze/getHtmlTemplate.mjs

@@ -2,7 +2,7 @@ import "node:module";
 import { findExists, fs } from "@modern-js/utils";
 import path from "path";
 import { HTML_PARTIALS_EXTENSIONS, HTML_PARTIALS_FOLDER } from "./constants.mjs";
-import * as __rspack_external__templates_mjs_4da4c6c8 from "./templates.mjs";
+import * as __rspack_external__templates_mjs_ab577925 from "./templates.mjs";
 const findPartials = (dir, entryName, position)=>{
     if (fs.existsSync(dir)) {
         const base = findExists(HTML_PARTIALS_EXTENSIONS.map((ext)=>path.resolve(dir, `${position}${ext}`)));
@@ -83,7 +83,7 @@ const getHtmlTemplate = async (entrypoints, hooks, { appContext, config })=>{
                 partials: getModifyHtmlPartials(partials)
             });
             const templatePath = path.resolve(internalDirectory, entryName, 'index.html');
-            fs.outputFileSync(templatePath, __rspack_external__templates_mjs_4da4c6c8.html(partials), 'utf8');
+            fs.outputFileSync(templatePath, __rspack_external__templates_mjs_ab577925.html(partials), 'utf8');
             htmlTemplates[entryName] = templatePath.replace(/\\/g, '/');
             partialsByEntrypoint[entryName] = partials;
             const bottomTemplate = findPartials(htmlDir, name, "bottom");

package/dist/esm-node/plugins/analyze/getServerRoutes.mjs

@@ -128,4 +128,20 @@ const getProdServerRoutes = (distDirectory)=>{
         throw new Error(`Failed to read routes from ${routeJSON}, please check if the file exists.`);
     }
 };
-export { getProdServerRoutes, getServerRoutes };
+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: path.resolve(distDirectory, builtEntry),
+            isAutoMount: true,
+            isMainEntry: route.entryName === mainEntryName
+        });
+    }
+    return [
+        ...byEntryName.values()
+    ];
+};
+export { getProdEntrypoints, getProdServerRoutes, getServerRoutes };

package/dist/esm-node/plugins/analyze/index.mjs

@@ -27,7 +27,7 @@ const analyze = ()=>({
                     if (checkIsBuildCommands()) fs.emptydirSync(appContext.internalDirectory);
                 } catch  {}
                 const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
-                const [{ getProdServerRoutes }] = await Promise.all([
+                const [{ getProdEntrypoints, getProdServerRoutes }] = await Promise.all([
                     import("./getServerRoutes.mjs")
                 ]);
                 if (apiOnly) {
@@ -46,6 +46,17 @@ const analyze = ()=>({
                     });
                     return;
                 }
+                if (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.mjs"),
                     import("./getServerRoutes.mjs"),
@@ -56,17 +67,14 @@ const analyze = ()=>({
                 });
                 debug("entrypoints: %o", entrypoints);
                 const routes = [];
-                if (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(),

package/dist/esm-node/plugins/analyze/isDefaultExportFunction.mjs

@@ -2,8 +2,8 @@ import "node:module";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
 import fs from "fs";
-import * as __rspack_external__babel_types_69e65b52 from "@babel/types";
-const isFunction = (node)=>__rspack_external__babel_types_69e65b52.isFunctionDeclaration(node) || __rspack_external__babel_types_69e65b52.isFunctionExpression(node) || __rspack_external__babel_types_69e65b52.isArrowFunctionExpression(node);
+import * as __rspack_external__babel_types_6e8337dd from "@babel/types";
+const isFunction = (node)=>__rspack_external__babel_types_6e8337dd.isFunctionDeclaration(node) || __rspack_external__babel_types_6e8337dd.isFunctionExpression(node) || __rspack_external__babel_types_6e8337dd.isArrowFunctionExpression(node);
 const isDefaultExportFunction = (file)=>{
     if (!file || !fs.existsSync(file)) return false;
     const ast = parse(fs.readFileSync(file, 'utf8'), {

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

@@ -0,0 +1,205 @@
+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/utils/universal";
+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)=>{
+    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: {
+            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 };