@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.2

package/src/backend-federation-build/config.ts

@@ -18,60 +18,24 @@ import {
   validateUltramodernBuildArtifact,
 } from '@modern-js/backend-federation-contracts';
 
-export const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
-
-export type CompactApp = {
-  id?: unknown;
-  kind?: unknown;
-  path?: unknown;
-  package?: unknown;
-  port?: unknown;
-  api?: {
-    prefix?: unknown;
-    stem?: unknown;
-  };
-  moduleFederation?: {
-    name?: unknown;
-    manifestUrl?: unknown;
-  };
-  backendFederation?: {
-    name?: unknown;
-    versionBoundary?: {
-      ui?: {
-        manifestUrl?: unknown;
-      };
-    };
-    executionSurfaces?: {
-      node?: {
-        remoteName?: unknown;
-        manifestUrl?: unknown;
-        containerEntry?: unknown;
-        remoteType?: unknown;
-      };
-    };
-  };
-  deliveryUnit?: {
-    unitId?: unknown;
-    buildMarker?: unknown;
-    sourceRevision?: unknown;
-    packageName?: unknown;
-    version?: unknown;
-  };
-  serverExecution?: {
-    node?: {
-      remoteName?: unknown;
-      manifestUrl?: unknown;
-      containerEntry?: unknown;
-      remoteType?: unknown;
-    };
-  };
-};
-
-export type CompactConfig = {
-  topology?: {
-    apps?: CompactApp[];
-  };
-};
+import {
+  DEVELOPMENT_OVERLAY_PATH,
+  type DevelopmentOverlay,
+  normalizeRelativePath,
+  REFERENCE_TOPOLOGY_PATH,
+  type ReferenceTopology,
+  type TopologyApp,
+} from '../workspace-topology';
+
+export {
+  DEVELOPMENT_OVERLAY_PATH,
+  type DevelopmentOverlay,
+  findWorkspaceRoot,
+  normalizeRelativePath,
+  REFERENCE_TOPOLOGY_PATH,
+  type ReferenceTopology,
+  type TopologyApp,
+} from '../workspace-topology';
 
 export type BackendFederationApp = {
   id: string;
@@ -84,13 +48,15 @@ export type BackendFederationApp = {
   deliveryUnit?: DeliveryUnitContractBlock;
   port: number;
   apiPrefix: string;
+  apiProtocol: 'rest' | 'rpc';
+  rpcPath?: string;
   apiStem: string;
   backendName: string;
   manifestUrl: string;
   containerEntry: string;
   remoteType: string;
   uiManifestUrl?: string;
-  compactDeliveryUnit?: {
+  topologyDeliveryUnit?: {
     unitId?: string;
     buildMarker?: string;
     sourceRevision?: string;
@@ -109,9 +75,6 @@ export type BackendFederationBuildIdentity = {
   artifact?: UltramodernBuildArtifact;
 };
 
-export const normalizeRelativePath = (value: string) =>
-  value.replace(/\\/gu, '/').replace(/^\.\/+/u, '');
-
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null;
 
@@ -169,11 +132,10 @@ const toPascalCase = (value: string) =>
 const stringValue = (value: unknown) =>
   typeof value === 'string' && value.length > 0 ? value : undefined;
 
-const createBackendName = (app: CompactApp, id: string) => {
+const createBackendName = (app: TopologyApp, id: string) => {
   const configuredName =
     stringValue(app.backendFederation?.name) ??
-    stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName) ??
-    stringValue(app.serverExecution?.node?.remoteName);
+    stringValue(app.backendFederation?.executionSurfaces?.node?.remoteName);
 
   if (configuredName) {
     return configuredName;
@@ -183,20 +145,27 @@ const createBackendName = (app: CompactApp, id: string) => {
   return mfName ? `${mfName}Backend` : `vertical${toPascalCase(id)}Backend`;
 };
 
-export const findWorkspaceRoot = (appDirectory: string) => {
-  let current = appDirectory;
-
-  while (true) {
-    if (existsSync(path.join(current, COMPACT_CONFIG_PATH))) {
-      return current;
-    }
-
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return undefined;
-    }
-    current = parent;
+const rebaseDefaultLocalUrl = (
+  value: string,
+  defaultPort: number,
+  publicOrigin: string,
+) => {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    return value;
+  }
+  if (
+    url.protocol !== 'http:' ||
+    url.hostname !== 'localhost' ||
+    Number(url.port) !== defaultPort ||
+    url.username ||
+    url.password
+  ) {
+    return value;
   }
+  return `${publicOrigin}${url.pathname}${url.search}${url.hash}`;
 };
 
 export const resolveWorkspaceSourceRevision = async (workspaceRoot: string) => {
@@ -240,50 +209,121 @@ export const createStampedDeliveryUnit = (input: {
   return deliveryUnitContractBlock(record as DeliveryUnitRecord);
 };
 
-export const createAppFromCompactMetadata = (
+export const createAppFromTopology = (
   workspaceRoot: string,
   appDirectory: string,
-  compactApp: CompactApp,
+  topologyApp: TopologyApp,
+  overlay: DevelopmentOverlay,
+  packageManifest: { name?: unknown; version?: unknown },
 ): BackendFederationApp | undefined => {
-  const id = stringValue(compactApp.id);
-  const appPath = stringValue(compactApp.path);
+  const id = stringValue(topologyApp.id);
+  const appPath = stringValue(topologyApp.path);
 
-  if (!id || compactApp.kind !== 'vertical' || !isRecord(compactApp.api)) {
+  if (
+    !id ||
+    !appPath ||
+    topologyApp.kind !== 'vertical' ||
+    !isRecord(topologyApp.api) ||
+    !isRecord(topologyApp.backendFederation)
+  ) {
     return undefined;
   }
 
-  const directory = appPath
-    ? normalizeRelativePath(appPath)
-    : `verticals/${id}`;
+  const directory = normalizeRelativePath(appPath);
   if (path.resolve(workspaceRoot, directory) !== path.resolve(appDirectory)) {
     return undefined;
   }
 
-  const port =
-    typeof compactApp.port === 'number' ? compactApp.port : undefined;
-  if (port === undefined) {
-    return undefined;
+  const defaultPort = overlay.ports?.[id];
+  if (
+    typeof defaultPort !== 'number' ||
+    !Number.isInteger(defaultPort) ||
+    defaultPort < 1 ||
+    defaultPort > 65535
+  ) {
+    throw new Error(
+      `[backend-federation-build] Invalid development port for ${id}.`,
+    );
+  }
+  const portEnv =
+    stringValue(topologyApp.portEnv) ??
+    `VERTICAL_${(stringValue(topologyApp.domain) ?? id)
+      .replace(/[^a-zA-Z0-9]/gu, '_')
+      .toUpperCase()}_PORT`;
+  const port = Number(process.env[portEnv] ?? defaultPort);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(
+      `[backend-federation-build] Invalid ${portEnv} development port for ${id}.`,
+    );
+  }
+  const publicUrlEnv = stringValue(topologyApp.cloudflare?.publicUrlEnv);
+  const configuredPublicUrl = publicUrlEnv
+    ? process.env[publicUrlEnv]?.trim()
+    : undefined;
+  let publicOrigin = `http://localhost:${port}`;
+  if (configuredPublicUrl) {
+    let url: URL;
+    try {
+      url = new URL(configuredPublicUrl);
+    } catch {
+      throw new Error(
+        `[backend-federation-build] Invalid ${publicUrlEnv} public URL for ${id}.`,
+      );
+    }
+    if (
+      !['http:', 'https:'].includes(url.protocol) ||
+      url.username ||
+      url.password
+    ) {
+      throw new Error(
+        `[backend-federation-build] Invalid ${publicUrlEnv} public URL for ${id}.`,
+      );
+    }
+    publicOrigin = url.origin;
   }
 
-  const apiPrefix = stringValue(compactApp.api.prefix) ?? `/${id}-api`;
-  const apiStem = stringValue(compactApp.api.stem) ?? id;
-  const backendName = createBackendName(compactApp, id);
-  const manifestUrl =
-    stringValue(
-      compactApp.backendFederation?.executionSurfaces?.node?.manifestUrl,
-    ) ??
-    stringValue(compactApp.serverExecution?.node?.manifestUrl) ??
-    `http://localhost:${port}/${BACKEND_MANIFEST_FILE}`;
-  const containerEntry =
-    stringValue(
-      compactApp.backendFederation?.executionSurfaces?.node?.containerEntry,
-    ) ??
-    stringValue(compactApp.serverExecution?.node?.containerEntry) ??
-    `http://localhost:${port}/${BACKEND_REMOTE_ENTRY_FILE}`;
+  const apiPrefix = stringValue(topologyApp.api.bff?.prefix) ?? `/${id}-api`;
+  const apiProtocol = topologyApp.api.protocol ?? 'rest';
+  if (apiProtocol !== 'rest' && apiProtocol !== 'rpc') {
+    throw new Error(
+      `[backend-federation-build] Unsupported API protocol for ${id}.`,
+    );
+  }
+  const rpcPath =
+    apiProtocol === 'rpc' ? stringValue(topologyApp.api.rpcPath) : undefined;
+  if (
+    apiProtocol === 'rpc' &&
+    (!rpcPath || topologyApp.api.rpcSerialization !== 'json')
+  ) {
+    throw new Error(
+      `[backend-federation-build] Missing JSON RPC route metadata for ${id}.`,
+    );
+  }
+  const apiStem = stringValue(topologyApp.api.stem) ?? id;
+  const backendName = createBackendName(topologyApp, id);
+  const nodeOverlay = overlay.serverExecution?.[id]?.node;
+  if (!isRecord(nodeOverlay)) {
+    throw new Error(
+      `[backend-federation-build] Missing declared Node server execution for ${id}.`,
+    );
+  }
+  const manifestUrl = rebaseDefaultLocalUrl(
+    stringValue(nodeOverlay?.manifestUrl) ??
+      `http://localhost:${defaultPort}/${BACKEND_MANIFEST_FILE}`,
+    defaultPort,
+    publicOrigin,
+  );
+  const containerEntry = rebaseDefaultLocalUrl(
+    stringValue(nodeOverlay?.containerEntry) ??
+      `http://localhost:${defaultPort}/${BACKEND_REMOTE_ENTRY_FILE}`,
+    defaultPort,
+    publicOrigin,
+  );
   const configuredRemoteType =
+    stringValue(nodeOverlay?.remoteType) ??
     stringValue(
-      compactApp.backendFederation?.executionSurfaces?.node?.remoteType,
-    ) ?? stringValue(compactApp.serverExecution?.node?.remoteType);
+      topologyApp.backendFederation?.executionSurfaces?.node?.remoteType,
+    );
   if (
     configuredRemoteType !== undefined &&
     configuredRemoteType !== 'commonjs-module'
@@ -300,18 +340,24 @@ export const createAppFromCompactMetadata = (
     );
   }
   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)
+  const packageName = stringValue(packageManifest.name);
+  const version = stringValue(packageManifest.version);
+  if (stringValue(topologyApp.package) !== packageName || !version) {
+    throw new Error(
+      `[backend-federation-build] Topology package identity must match package.json for ${id}.`,
+    );
+  }
+  const declaredUiManifestUrl = stringValue(overlay.manifests?.[id]);
+  const uiManifestUrl = declaredUiManifestUrl
+    ? rebaseDefaultLocalUrl(declaredUiManifestUrl, defaultPort, publicOrigin)
+    : undefined;
+  const topologyDeliveryUnit = isRecord(topologyApp.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),
+        unitId: stringValue(topologyApp.deliveryUnit.unitId),
+        buildMarker: stringValue(topologyApp.deliveryUnit.buildMarker),
+        sourceRevision: stringValue(topologyApp.deliveryUnit.sourceRevision),
+        packageName: stringValue(topologyApp.deliveryUnit.packageName),
+        version: stringValue(topologyApp.deliveryUnit.version),
       }
     : undefined;
 
@@ -319,15 +365,18 @@ export const createAppFromCompactMetadata = (
     id,
     directory,
     packageName,
+    version,
     port,
     apiPrefix,
+    apiProtocol,
+    rpcPath,
     apiStem,
     backendName,
     manifestUrl,
     containerEntry,
     remoteType,
     uiManifestUrl,
-    compactDeliveryUnit,
+    topologyDeliveryUnit,
   };
 };
 
@@ -335,22 +384,39 @@ export const findBackendFederationApp = async (
   workspaceRoot: string,
   appDirectory: string,
 ) => {
-  const compactConfigPath = path.join(workspaceRoot, COMPACT_CONFIG_PATH);
-  const compactConfig = await readJsonFile<CompactConfig>(compactConfigPath);
-  const apps = Array.isArray(compactConfig.topology?.apps)
-    ? compactConfig.topology.apps
-    : [];
+  const topologyPath = path.join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
+  const topology = await readJsonFile<ReferenceTopology>(topologyPath);
+  if (!isRecord(topology) || !Array.isArray(topology.verticals)) {
+    throw new Error(
+      `[backend-federation-build] Invalid declared topology at ${topologyPath}.`,
+    );
+  }
+  const overlayPath = path.join(workspaceRoot, DEVELOPMENT_OVERLAY_PATH);
+  const overlay = await readJsonFile<DevelopmentOverlay>(overlayPath);
+  if (!isRecord(overlay) || !isRecord(overlay.ports)) {
+    throw new Error(
+      `[backend-federation-build] Invalid development overlay at ${overlayPath}.`,
+    );
+  }
+  const packageManifest = await readJsonFile<{
+    name?: unknown;
+    version?: unknown;
+  }>(path.join(appDirectory, 'package.json'));
 
-  for (const app of apps) {
-    const resolved = createAppFromCompactMetadata(
+  for (const app of topology.verticals) {
+    const resolved = createAppFromTopology(
       workspaceRoot,
       appDirectory,
       app,
+      overlay,
+      packageManifest,
     );
     if (resolved) {
       return resolved;
     }
   }
 
-  return undefined;
+  throw new Error(
+    `[backend-federation-build] ${appDirectory} is missing from the declared reference topology.`,
+  );
 };

package/src/backend-federation-build/emit.ts

@@ -9,6 +9,14 @@ import {
   ULTRAMODERN_BUILD_ARTIFACT_FILE,
 } from '@modern-js/backend-federation-contracts';
 import { createBackendFederationEntryIntegrity } from '@modern-js/server-runtime-extensions/backend-federation-security/node';
+import {
+  emitRendererBuildArtifact,
+  type FinalizedRendererBuildOutput,
+  type RendererBuildOutputContext,
+  type RendererBuildOutputOptions,
+  stampFinalizedRendererBuildArtifact,
+  validateFinalizedRendererBuild,
+} from '../release-envelope/renderer-output-stamp';
 import {
   createBackendManifest,
   createBackendRemoteEntrySource,
@@ -16,10 +24,10 @@ import {
 import {
   type BackendFederationApp,
   buildArtifactPathFor,
-  COMPACT_CONFIG_PATH,
   createStampedDeliveryUnit,
   findBackendFederationApp,
   findWorkspaceRoot,
+  REFERENCE_TOPOLOGY_PATH,
   readBuildIdentity,
   resolveWorkspaceSourceRevision,
 } from './config';
@@ -35,9 +43,16 @@ export type BackendFederationArtifactResult = {
   remoteType: string;
 };
 
+export type BackendFederationBuildOptions = {
+  resolveRendererBuild?: RendererBuildOutputOptions['resolveRendererBuild'];
+  rendererBuildPlugin?: RendererBuildOutputOptions['rendererBuildPlugin'];
+  entrypoints?: RendererBuildOutputContext['entrypoints'];
+};
+
 export const emitBackendFederationArtifacts = async (
   appDirectory: string,
   distDirectory: string,
+  options: BackendFederationBuildOptions = {},
 ): Promise<BackendFederationArtifactResult | undefined> => {
   const workspaceRoot = findWorkspaceRoot(appDirectory);
   if (!workspaceRoot) {
@@ -58,13 +73,13 @@ export const emitBackendFederationArtifacts = async (
     return undefined;
   }
   const buildIdentity = await readBuildIdentity(appDirectory);
-  const compactDeliveryUnit = app.compactDeliveryUnit;
-  const hasCompactDeliveryUnit =
-    compactDeliveryUnit !== undefined &&
-    (compactDeliveryUnit.unitId !== undefined ||
-      compactDeliveryUnit.buildMarker !== undefined ||
-      compactDeliveryUnit.packageName !== undefined ||
-      compactDeliveryUnit.version !== undefined);
+  const topologyDeliveryUnit = app.topologyDeliveryUnit;
+  const hasTopologyDeliveryUnit =
+    topologyDeliveryUnit !== undefined &&
+    (topologyDeliveryUnit.unitId !== undefined ||
+      topologyDeliveryUnit.buildMarker !== undefined ||
+      topologyDeliveryUnit.packageName !== undefined ||
+      topologyDeliveryUnit.version !== undefined);
   const hasBuildIdentity =
     buildIdentity.unitId !== undefined ||
     buildIdentity.buildVersion !== undefined ||
@@ -72,7 +87,7 @@ export const emitBackendFederationArtifacts = async (
     buildIdentity.version !== undefined;
 
   if (hasBuildIdentity) {
-    const compactConfigPath = path.join(workspaceRoot, COMPACT_CONFIG_PATH);
+    const topologyPath = path.join(workspaceRoot, REFERENCE_TOPOLOGY_PATH);
     const buildIdentityPath = buildArtifactPathFor(appDirectory);
     const mismatches: string[] = [];
     const compare = (
@@ -89,45 +104,73 @@ export const emitBackendFederationArtifacts = async (
     };
     compare('appId', app.id, buildIdentity.appId, 'topology');
 
-    if (hasCompactDeliveryUnit) {
-      compare('unitId', compactDeliveryUnit?.unitId, buildIdentity.unitId);
+    if (hasTopologyDeliveryUnit) {
+      compare('unitId', topologyDeliveryUnit?.unitId, buildIdentity.unitId);
       compare(
         'buildMarker/build',
-        compactDeliveryUnit?.buildMarker,
+        topologyDeliveryUnit?.buildMarker,
         buildIdentity.buildVersion,
       );
       compare(
         'packageName',
-        compactDeliveryUnit?.packageName,
+        topologyDeliveryUnit?.packageName,
         buildIdentity.packageName,
       );
-      compare('version', compactDeliveryUnit?.version, buildIdentity.version);
+      compare('version', topologyDeliveryUnit?.version, buildIdentity.version);
     }
+    compare(
+      'packageName',
+      app.packageName,
+      buildIdentity.packageName,
+      'package.json',
+    );
+    compare(
+      'packageName',
+      topologyDeliveryUnit?.packageName,
+      app.packageName,
+      'topology',
+    );
+    compare('version', app.version, buildIdentity.version, 'package.json');
+    compare('version', topologyDeliveryUnit?.version, app.version, 'topology');
 
     if (mismatches.length > 0) {
       throw new Error(
-        `[backend-federation-build] Delivery-unit identity drift between ${compactConfigPath} (topology) and ${buildIdentityPath}: ${mismatches.join('; ')}`,
+        `[backend-federation-build] Delivery-unit identity drift between ${topologyPath}, package.json and ${buildIdentityPath}: ${mismatches.join('; ')}`,
       );
     }
   }
 
-  const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
+  const unitId = topologyDeliveryUnit?.unitId ?? buildIdentity.unitId;
   const generationBuildMarker =
-    compactDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
-  const sourceRevision = await resolveWorkspaceSourceRevision(workspaceRoot);
+    topologyDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
+  let finalizedRendererBuild: FinalizedRendererBuildOutput | undefined;
+  if (options.resolveRendererBuild && buildIdentity.artifact?.surfaces.ui) {
+    if (!options.entrypoints?.length)
+      throw new Error(
+        '[backend-federation-build] Renderer output stamping requires the actual finalized application entries.',
+      );
+    const context = {
+      appDirectory,
+      distDirectory,
+      entrypoints: options.entrypoints,
+    };
+    finalizedRendererBuild = await options.resolveRendererBuild(context);
+    validateFinalizedRendererBuild(finalizedRendererBuild, context, app.id);
+  }
+  const sourceRevision =
+    finalizedRendererBuild?.sourceRevision ??
+    (await resolveWorkspaceSourceRevision(workspaceRoot));
   const buildVersion =
-    generationBuildMarker && unitId
+    finalizedRendererBuild?.buildMarker ??
+    (generationBuildMarker && unitId
       ? resolveUltramodernReleaseIdentity({
           generationBuildMarker,
           unitId,
           workspaceRoot,
         }).buildMarker
-      : undefined;
-  const packageName =
-    compactDeliveryUnit?.packageName ??
-    buildIdentity.packageName ??
-    app.packageName;
-  const version = compactDeliveryUnit?.version ?? buildIdentity.version;
+      : undefined);
+  const packageName = app.packageName;
+  const version = app.version;
   const deliveryUnit = createStampedDeliveryUnit({
     appId: app.id,
     unitId,
@@ -136,13 +179,20 @@ export const emitBackendFederationArtifacts = async (
     version,
     sourceRevision,
   });
-  const stampedBuildArtifact = buildIdentity.artifact
+  let stampedBuildArtifact = buildIdentity.artifact
     ? stampUltramodernBuildArtifactIdentity(buildIdentity.artifact, {
         buildMarker:
           buildVersion ?? buildIdentity.artifact.deliveryUnit.buildMarker,
         sourceRevision,
       })
     : undefined;
+  if (finalizedRendererBuild && stampedBuildArtifact?.surfaces.ui) {
+    stampedBuildArtifact = stampFinalizedRendererBuildArtifact(
+      stampedBuildArtifact,
+      finalizedRendererBuild,
+      { appDirectory, distDirectory, entrypoints: options.entrypoints! },
+    );
+  }
 
   const resolvedApp: BackendFederationApp = {
     ...app,
@@ -188,15 +238,46 @@ export const emitBackendFederationArtifacts = async (
   };
 };
 
-export default () => ({
-  name: '@modern-js/backend-federation-build',
-  setup(api: {
-    getAppContext(): { appDirectory: string; distDirectory: string };
-    onAfterBuild(handler: () => Promise<void>): void;
-  }) {
-    api.onAfterBuild(async () => {
-      const { appDirectory, distDirectory } = api.getAppContext();
-      await emitBackendFederationArtifacts(appDirectory, distDirectory);
-    });
-  },
-});
+export default (
+  options: Omit<BackendFederationBuildOptions, 'entrypoints'> = {},
+) => {
+  if (options.resolveRendererBuild && !options.rendererBuildPlugin) {
+    throw new Error(
+      '[backend-federation-build] A finalized renderer resolver requires its owning metadata producer plugin.',
+    );
+  }
+  return {
+    name: '@modern-js/backend-federation-build',
+    pre: options.resolveRendererBuild ? [options.rendererBuildPlugin!] : [],
+    required: options.resolveRendererBuild
+      ? [options.rendererBuildPlugin!]
+      : [],
+    setup(api: {
+      getAppContext(): {
+        appDirectory: string;
+        distDirectory: string;
+        entrypoints?: RendererBuildOutputContext['entrypoints'];
+        apiOnly?: boolean;
+      };
+      onAfterBuild(handler: () => Promise<void>): void;
+    }) {
+      api.onAfterBuild(async () => {
+        const { appDirectory, distDirectory, entrypoints, apiOnly } =
+          api.getAppContext();
+        if (options.resolveRendererBuild && !apiOnly) {
+          await emitRendererBuildArtifact(
+            { appDirectory, distDirectory, entrypoints: entrypoints ?? [] },
+            {
+              resolveRendererBuild: options.resolveRendererBuild,
+              rendererBuildPlugin: options.rendererBuildPlugin!,
+            },
+          );
+        }
+        await emitBackendFederationArtifacts(appDirectory, distDirectory, {
+          ...options,
+          entrypoints,
+        });
+      });
+    },
+  };
+};

package/src/backend-federation-build/index.ts

@@ -1,2 +1,5 @@
-export type { BackendFederationArtifactResult } from './emit';
+export type {
+  BackendFederationArtifactResult,
+  BackendFederationBuildOptions,
+} from './emit';
 export { default, emitBackendFederationArtifacts } from './emit';