@bleedingdev/modern-js-ultramodern-create 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/templates/workspace-scripts/generate-node-backend-federation.mjs

@@ -9,13 +9,14 @@ const workspaceRoot = path.resolve(
   process.env.ULTRAMODERN_WORKSPACE_ROOT ??
     path.join(path.dirname(fileURLToPath(import.meta.url)), '../..'),
 );
-const configPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
+const topologyPath = path.join(workspaceRoot, 'topology/reference-topology.json');
+const overlayPath = path.join(workspaceRoot, 'topology/local-overlays/development.json');
 const { build } = createRequire(import.meta.url)('esbuild');
 // Keep these constants/checks in sync with
-// @modern-js/utils/universal backend-federation-contract. Generated workspace
+// @modern-js/backend-federation-contracts backend-federation-contract. Generated workspace
 // scripts do not currently import @modern-js/utils directly.
 const contractVersion = 'microvertical-server-effect-v1';
-const nodeAdapterVersion = 'backend-mf-effect-v1';
+const nodeAdapterVersion = 'backend-mf-effect-v2';
 
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
@@ -27,43 +28,23 @@ function readBuildIdentity(app) {
     app.path,
     'shared/ultramodern-build.json',
   );
-  if (fs.existsSync(buildArtifactPath)) {
-    const artifact = readJson(buildArtifactPath);
-    const deliveryUnit = artifact.deliveryUnit ?? {};
-    return {
-      buildVersion: deliveryUnit.buildMarker ?? deliveryUnit.build,
-      packageName: deliveryUnit.packageName,
-      version: deliveryUnit.version,
-      unitId: deliveryUnit.unitId,
-      sourceRevision: deliveryUnit.sourceRevision,
-    };
+  const artifact = readJson(buildArtifactPath);
+  const deliveryUnit = artifact.deliveryUnit ?? {};
+  const manifest = readJson(path.join(workspaceRoot, app.path, 'package.json'));
+  if (
+    app.package !== manifest.name ||
+    app.deliveryUnit?.unitId !== deliveryUnit.unitId ||
+    deliveryUnit.packageName !== manifest.name ||
+    deliveryUnit.version !== manifest.version
+  ) {
+    throw new Error(`${app.id} topology, package.json and stamped build identity disagree`);
   }
-
-  const buildModulePath = path.join(
-    workspaceRoot,
-    app.path,
-    'shared/ultramodern-build.ts',
-  );
-  if (!fs.existsSync(buildModulePath)) {
-    return {};
-  }
-  console.warn(
-    `[backend-federation] ${path.relative(
-      workspaceRoot,
-      buildArtifactPath,
-    )} missing; falling back to legacy regex parsing of ${path.relative(
-      workspaceRoot,
-      buildModulePath,
-    )}.`,
-  );
-
-  const source = fs.readFileSync(buildModulePath, 'utf8');
   return {
-    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],
+    buildVersion: deliveryUnit.buildMarker ?? deliveryUnit.build,
+    packageName: deliveryUnit.packageName,
+    version: deliveryUnit.version,
+    unitId: deliveryUnit.unitId,
+    sourceRevision: deliveryUnit.sourceRevision,
   };
 }
 
@@ -94,8 +75,8 @@ function parseArgs(argv) {
   return options;
 }
 
-function backendApps(config, appFilter) {
-  return (config.topology?.apps ?? []).filter(app => {
+function backendApps(topology, appFilter) {
+  return topology.verticals.filter(app => {
     if (app.kind !== 'vertical') {
       return false;
     }
@@ -107,7 +88,7 @@ function backendApps(config, appFilter) {
 }
 
 function backendFederationMetadata(app) {
-  return app.backendFederation ?? app.api?.backendFederation;
+  return app.backendFederation;
 }
 
 function backendFederationExposes(app) {
@@ -133,7 +114,7 @@ function backendFederationExposes(app) {
 
 function normalizeBackendFederation(app) {
   const backend = backendFederationMetadata(app);
-  const nodeSurface = backend.executionSurfaces?.node ?? {};
+  const nodeSurface = app.nodeExecution ?? {};
   const exposes = backendFederationExposes(app);
 
   return {
@@ -168,39 +149,40 @@ async function createRemoteEntrySource(app, outputDir) {
   const exposes = backendFederationExposes(app);
   const buildIdentity = readBuildIdentity(app);
   const effectApiPath = path.join(workspaceRoot, app.path, 'api/effect-api.ts');
-  const source = `import * as exposedNamespace from ${JSON.stringify(
-    effectApiPath,
-  )};
+  const source = `import { adoptEffectBffShareScope } from '@modern-js/bff-effect/effect-edge';
 
-const exposedModule = {
-  ...exposedNamespace,
-  backendFederationContract: {
-    ...(exposedNamespace.backendFederationContract ?? {}),
-    compatibility: {
-      ...(exposedNamespace.backendFederationContract?.compatibility ?? {}),
-      build: ${JSON.stringify(buildIdentity.buildVersion)},
-      contractVersion: ${JSON.stringify(backend.contractVersion)},
-      nodeAdapterVersion: ${JSON.stringify(backend.nodeAdapterVersion)},
-      packageName: ${JSON.stringify(buildIdentity.packageName)},
-      sourceRevision: ${JSON.stringify(buildIdentity.sourceRevision)},
-      unitId: ${JSON.stringify(buildIdentity.unitId)},
+// The expose evaluates lazily so defineEffectBff registers its handler
+// factories with the registry the host shares through init().
+let exposedModule;
+const loadExposedModule = () =>
+  (exposedModule ??= import(${JSON.stringify(effectApiPath)}).then(exposedNamespace => ({
+    ...exposedNamespace,
+    backendFederationContract: {
+      ...(exposedNamespace.backendFederationContract ?? {}),
+      compatibility: {
+        ...(exposedNamespace.backendFederationContract?.compatibility ?? {}),
+        build: ${JSON.stringify(buildIdentity.buildVersion)},
+        contractVersion: ${JSON.stringify(backend.contractVersion)},
+        nodeAdapterVersion: ${JSON.stringify(backend.nodeAdapterVersion)},
+        packageName: ${JSON.stringify(buildIdentity.packageName)},
+        sourceRevision: ${JSON.stringify(buildIdentity.sourceRevision)},
+        unitId: ${JSON.stringify(buildIdentity.unitId)},
+      },
+      name: ${JSON.stringify(backend.name)},
+      role: 'microvertical-server',
+      runtimeFramework: 'effect',
+      strictEffectApproach: true,
     },
-    name: ${JSON.stringify(backend.name)},
-    role: 'microvertical-server',
-    runtimeFramework: 'effect',
-    strictEffectApproach: true,
-  },
-};
+  })));
 const factories = {
 ${exposes
-  .map(
-    expose =>
-      `${JSON.stringify(expose)}: () => Promise.resolve(exposedModule),`,
-  )
+  .map(expose => `${JSON.stringify(expose)}: loadExposedModule,`)
   .join('\n')}
 };
 
-function init() {}
+function init(shareScope) {
+  return adoptEffectBffShareScope(shareScope);
+}
 
 function get(id) {
   const factory = factories[id];
@@ -242,13 +224,8 @@ function createManifest(app, outputDir, entrySource) {
     );
   }
   const buildIdentity = readBuildIdentity(app);
-  const compactDeliveryUnit =
-    app.deliveryUnit && typeof app.deliveryUnit === 'object'
-      ? app.deliveryUnit
-      : undefined;
-  const unitId = compactDeliveryUnit?.unitId ?? buildIdentity.unitId;
-  const sourceRevision =
-    compactDeliveryUnit?.sourceRevision ?? buildIdentity.sourceRevision;
+  const unitId = app.deliveryUnit?.unitId ?? buildIdentity.unitId;
+  const sourceRevision = app.deliveryUnit?.sourceRevision ?? buildIdentity.sourceRevision;
   const publicPath = new URL('.', backend.containerEntry).href;
   return {
     schemaVersion: 1,
@@ -349,8 +326,22 @@ function createManifest(app, outputDir, entrySource) {
 }
 
 const options = parseArgs(process.argv.slice(2));
-const config = readJson(configPath);
-const apps = backendApps(config, options.app);
+const topology = readJson(topologyPath);
+const overlay = readJson(overlayPath);
+if (topology.schemaVersion !== 1 || !Array.isArray(topology.verticals)) {
+  throw new Error('Invalid topology/reference-topology.json');
+}
+const apps = backendApps(topology, options.app).map(app => {
+  const nodeExecution = overlay.serverExecution?.[app.id]?.node;
+  if (
+    typeof app.path !== 'string' ||
+    !nodeExecution?.manifestUrl ||
+    !nodeExecution?.containerEntry
+  ) {
+    throw new Error(`${app.id} requires a topology path and Node execution URLs`);
+  }
+  return { ...app, nodeExecution };
+});
 
 if (options.app && apps.length === 0) {
   throw new Error(`No generated backend federation app matched ${options.app}`);

package/templates/workspace-scripts/generate-public-surface-assets.mjs

@@ -2,155 +2,56 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { tsImport } from 'tsx/esm/api';
 
 const workspaceRoot = path.resolve(
   process.env.ULTRAMODERN_WORKSPACE_ROOT ??
     path.join(path.dirname(fileURLToPath(import.meta.url)), '..'),
 );
-const compactConfigPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
+const topologyPath = path.join(workspaceRoot, 'topology/reference-topology.json');
 
 function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
 }
 
-function toKebabCase(value) {
-  return String(value)
-    .trim()
-    .replace(/([a-z0-9])([A-Z])/gu, '$1-$2')
-    .replace(/[^a-zA-Z0-9._-]+/gu, '-')
-    .replace(/[._]+/gu, '-')
-    .toLowerCase()
-    .replace(/-+/gu, '-')
-    .replace(/^-+|-+$/gu, '');
-}
-
-function toEnvSegment(value) {
-  return toKebabCase(value).replace(/-/gu, '_').toUpperCase();
-}
-
-function normalizeRelativePath(value) {
-  return String(value ?? '').replace(/\\/gu, '/').replace(/^\.\/+/u, '');
-}
-
-function appNamespace(app) {
-  return app.kind === 'shell' ? 'shell' : (app.domain ?? app.id);
-}
-
-function defaultPortEnv(app) {
-  return app.kind === 'shell'
-    ? 'SHELL_SUPER_APP_PORT'
-    : `VERTICAL_${toEnvSegment(app.domain ?? app.id)}_PORT`;
-}
-
-function defaultPort(app) {
-  return app.kind === 'shell' ? 3020 : 3030;
-}
-
-function normalizeCompactApp(rawApp) {
-  const id = String(rawApp.id);
-  const kind = rawApp.kind === 'vertical' ? 'vertical' : 'shell';
-  const appPath =
-    typeof rawApp.path === 'string'
-      ? normalizeRelativePath(rawApp.path)
-      : kind === 'shell'
-        ? 'apps/shell-super-app'
-        : `verticals/${toKebabCase(id)}`;
-  const packageSuffix =
-    typeof rawApp.packageSuffix === 'string'
-      ? rawApp.packageSuffix
-      : appPath.split('/').at(-1) ?? id;
-  const domain =
-    typeof rawApp.domain === 'string'
-      ? rawApp.domain
-      : kind === 'vertical'
-        ? packageSuffix
-        : undefined;
-  const moduleFederation =
-    rawApp.moduleFederation && typeof rawApp.moduleFederation === 'object'
-      ? rawApp.moduleFederation
-      : {};
-
-  return {
-    id,
-    kind,
-    path: appPath,
-    packageSuffix,
-    domain,
-    port:
-      typeof rawApp.port === 'number'
-        ? rawApp.port
-        : defaultPort({ id, kind, domain }),
-    portEnv:
-      typeof rawApp.portEnv === 'string'
-        ? rawApp.portEnv
-        : defaultPortEnv({ id, kind, domain }),
-    mfName:
-      typeof moduleFederation.name === 'string'
-        ? moduleFederation.name
-        : kind === 'shell'
-          ? 'shellSuperApp'
-          : `vertical${toKebabCase(domain ?? id)
-              .split('-')
-              .filter(Boolean)
-              .map(part => part.charAt(0).toUpperCase() + part.slice(1))
-              .join('')}`,
-    exposes: Array.isArray(moduleFederation.exposes)
-      ? moduleFederation.exposes.filter(expose => typeof expose === 'string')
-      : [],
-    verticalRefs: Array.isArray(moduleFederation.verticalRefs)
-      ? moduleFederation.verticalRefs.filter(ref => typeof ref === 'string')
-      : [],
-    marker: {
-      appId: id,
-    },
-    routes:
-      rawApp.routes && typeof rawApp.routes === 'object'
-        ? rawApp.routes
-        : undefined,
-    api:
-      rawApp.api && typeof rawApp.api === 'object'
-        ? {
-            stem:
-              typeof rawApp.api.stem === 'string'
-                ? rawApp.api.stem
-                : domain ?? id,
-            prefix:
-              typeof rawApp.api.prefix === 'string'
-                ? rawApp.api.prefix
-                : `/${domain ?? id}-api`,
-          }
-        : undefined,
-  };
-}
-
-function createRouteOwnedEntries(app) {
-  const namespace = appNamespace(app);
-  const base = {
-    descriptionKey: `${namespace}.seo.description`,
-    mfBoundaryId: app.mfName,
-    namespace,
-    ownerAppId: app.id,
-    public: false,
-    indexable: false,
-    publicSurface: 'private-app-screen',
-  };
-
-  return [
-    {
-      ...base,
-      canonicalPath: '/',
-      id: app.kind === 'shell' ? 'shell-home' : `${app.id}-home`,
-      localisedPaths: {
-        cs: '/',
-        en: '/',
-      },
-      titleKey: app.kind === 'shell' ? 'shell.title' : `${namespace}.title`,
-    },
-  ];
+async function readRouteOwnedEntries(app) {
+  const appRoot = fs.realpathSync(path.join(workspaceRoot, app.path));
+  const workspaceReal = fs.realpathSync(workspaceRoot);
+  const relativeAppPath = path.relative(workspaceReal, appRoot);
+  if (!relativeAppPath || relativeAppPath === '..' ||
+      relativeAppPath.startsWith(`..${path.sep}`) || path.isAbsolute(relativeAppPath))
+    throw new Error(`${app.id} topology path escapes the workspace`);
+  const routesRoot = path.join(appRoot, 'src/routes');
+  if (!fs.existsSync(routesRoot)) {
+    if (app.surfaceProfile === 'api-only') return [];
+    throw new Error(`${app.id} is missing its route-owned metadata directory`);
+  }
+  const files = [];
+  function visit(directory) {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const file = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`${app.id} route metadata may not be a symbolic link`);
+      if (entry.isDirectory()) visit(file);
+      else if (entry.name === 'route.meta.ts') files.push(file);
+    }
+  }
+  visit(routesRoot);
+  const routes = [];
+  for (const file of files.sort()) {
+    const module = await tsImport(pathToFileURL(file).href, { parentURL: import.meta.url, tsconfig: false });
+    const route = module.routeMeta ?? module.default?.routeMeta ?? module.default?.default ?? module.default;
+    if (!route || typeof route !== 'object' || route.ownerAppId !== app.id ||
+        typeof route.id !== 'string' || typeof route.canonicalPath !== 'string' ||
+        !route.localisedPaths || typeof route.localisedPaths.en !== 'string' ||
+        typeof route.localisedPaths.cs !== 'string')
+      throw new Error(`${app.id} has invalid route-owned metadata in ${file}`);
+    routes.push(route);
+  }
+  return routes;
 }
 
-function createPublicRoutes(app) {
-  return createRouteOwnedEntries(app)
+function createPublicRoutes(routes) {
+  return routes
     .filter(route => route.public && route.indexable)
     .map(route => ({
       canonicalPath: route.canonicalPath,
@@ -163,15 +64,24 @@ function createPublicRoutes(app) {
     }));
 }
 
-function createPublicSurface(app) {
-  const publicRoutes = createPublicRoutes(app);
+function createPublicSurface(app, routes) {
+  const publicRoutes = createPublicRoutes(routes);
+  const routeEntries = publicRoutes.filter(route =>
+    Object.values(route.localisedPaths).every(routePath =>
+      !/(?:^|\/):[^/]+|\[[^\]]+\]|\*/u.test(routePath),
+    ),
+  ).map(route => ({ ...route,
+    canonicalUrlPath: createLocalisedPublicPath(route.localisedPaths.en, 'en'),
+    localeUrlPaths: Object.fromEntries(['en', 'cs'].map(language =>
+      [language, createLocalisedPublicPath(route.localisedPaths[language], language)])),
+  }));
   const basePublicSurface = {
     authoring: 'colocated-route-meta',
     artifactLifecycle: 'build-and-deploy-output',
     generatedManifest: './src/routes/ultramodern-route-metadata',
     source: 'route-owned-public-routes',
     metadataExport: './src/routes/ultramodern-route-metadata',
-    generator: 'scripts/generate-public-surface-assets.mts',
+    generator: 'ultramodern-create ultramodern public-surface',
     outputRoot: 'dist/public',
     cloudflareBuildOutputRoot: 'dist-cloudflare/public',
     privateRoutePolicy: 'omit-from-generated-public-surface',
@@ -192,8 +102,8 @@ function createPublicSurface(app) {
     },
     contentSources: [],
     publicRoutes,
-    routeEntries: [],
-    concreteUrlPaths: [],
+    routeEntries,
+    concreteUrlPaths: uniqueSorted(routeEntries.flatMap(route => Object.values(route.localeUrlPaths))),
   };
 
   return app.routes?.publicSurface &&
@@ -205,54 +115,34 @@ function createPublicSurface(app) {
     : basePublicSurface;
 }
 
-function createCloudflareDeploy(config, app) {
-  const packageScope =
-    typeof config.workspace?.packageScope === 'string'
-      ? config.workspace.packageScope
-      : path.basename(workspaceRoot);
-  const compatibilityDate =
-    typeof config.deploy?.worker?.compatibilityDate === 'string'
-      ? config.deploy.worker.compatibilityDate
-      : '2026-06-02';
-  return {
-    workerName: `${toKebabCase(packageScope)}-${app.packageSuffix}`.slice(0, 63),
-    publicUrlEnv: `ULTRAMODERN_PUBLIC_URL_${toEnvSegment(app.id)}`,
-    compatibilityDate,
-    compatibilityFlags: ['nodejs_compat', 'global_fetch_strictly_public'],
-  };
-}
-
-function synthesizeContractFromCompactConfig(config) {
-  const apps = Array.isArray(config.topology?.apps)
-    ? config.topology.apps.map(normalizeCompactApp)
-    : [];
-
+export async function readGeneratedContractView() {
+  const topology = readJson(topologyPath);
+  if (topology.schemaVersion !== 1 || !topology.shell || !Array.isArray(topology.verticals)) {
+    throw new Error('Invalid topology/reference-topology.json');
+  }
+  const apps = [topology.shell, ...topology.verticals, ...(topology.shells ?? [])];
   return {
-    sourcePath: compactConfigPath,
-    apps: apps.map(app => ({
-      ...app,
-      deploy: {
-        cloudflare: createCloudflareDeploy(config, app),
-      },
-      routes: {
-        publicSurface: createPublicSurface(app),
-      },
+    sourcePath: topologyPath,
+    apps: await Promise.all(apps.map(async app => {
+      if (typeof app.path !== 'string' || !app.path) {
+        throw new Error(`${app.id} topology path is missing`);
+      }
+      const routes = await readRouteOwnedEntries(app);
+      return {
+        id: app.id,
+        kind: app.kind,
+        surfaceProfile: app.surfaceProfile,
+        path: app.path,
+        domain: app.domain,
+        mfName: app.moduleFederation?.name,
+        marker: { appId: app.id },
+        deploy: { cloudflare: app.cloudflare },
+        routes: { publicSurface: createPublicSurface(app, routes) },
+      };
     })),
   };
 }
 
-function readGeneratedContractView() {
-  if (fs.existsSync(compactConfigPath)) {
-    return synthesizeContractFromCompactConfig(readJson(compactConfigPath));
-  }
-  throw new Error(
-    `Missing UltraModern config. Expected ${path.relative(
-      workspaceRoot,
-      compactConfigPath,
-    )}.`,
-  );
-}
-
 function parseArgs(argv) {
   const parsed = {
     appId: undefined,
@@ -289,7 +179,7 @@ function parseArgs(argv) {
 
 function printHelp() {
   process.stdout.write(`Usage:
-  node scripts/generate-public-surface-assets.mts --app shell-super-app [--target dist|cloudflare-dist] [--require-public-origin]
+  ultramodern-create ultramodern public-surface --app shell-super-app [--target dist|cloudflare-dist] [--require-public-origin]
 
 Set each app's production URL using the contract env key, for example:
   ULTRAMODERN_PUBLIC_URL_SHELL_SUPER_APP=https://example.com
@@ -714,19 +604,27 @@ function writeText(outputDir, fileName, content) {
   fs.writeFileSync(path.join(outputDir, fileName), content);
 }
 
-async function generatePublicSurfaceAssets(app, target, requirePublicOrigin) {
+export async function resolvePublicSurface(app) {
   const publicSurface = app.routes?.publicSurface ?? {};
   const languages = publicSurface.languages ?? ['en', 'cs'];
-  const outputDir = ensureOutputDir(app, target);
-  const shouldRequirePublicOrigin =
-    requirePublicOrigin ||
-    process.env.ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS === 'true';
   const routeEntries = mergeRouteEntries(
     publicSurface.routeEntries ?? [],
     await expandContentSources(app, publicSurface, languages),
     languages,
   );
-  const urlPaths = createConcreteUrlPaths(routeEntries, languages);
+  return {
+    ...publicSurface,
+    routeEntries,
+    concreteUrlPaths: createConcreteUrlPaths(routeEntries, languages),
+  };
+}
+
+async function generatePublicSurfaceAssets(app, target, requirePublicOrigin) {
+  const publicSurface = await resolvePublicSurface(app);
+  const languages = publicSurface.languages ?? ['en', 'cs'];
+  const outputDir = ensureOutputDir(app, target);
+  const routeEntries = publicSurface.routeEntries;
+  const urlPaths = publicSurface.concreteUrlPaths;
 
   if (routeEntries.length === 0) {
     writeText(outputDir, 'robots.txt', renderRobotsTxt([], undefined));
@@ -735,7 +633,7 @@ async function generatePublicSurfaceAssets(app, target, requirePublicOrigin) {
     return;
   }
 
-  const origin = resolveOrigin(app, shouldRequirePublicOrigin);
+  const origin = resolveOrigin(app, requirePublicOrigin);
   if (!origin) {
     writeText(outputDir, 'robots.txt', renderRobotsTxt([], undefined));
     removeIfExists(outputDir, 'sitemap.xml');
@@ -748,19 +646,21 @@ async function generatePublicSurfaceAssets(app, target, requirePublicOrigin) {
   writeText(outputDir, 'robots.txt', renderRobotsTxt(urlPaths, `${origin}/sitemap.xml`));
 }
 
-try {
-  const args = parseArgs(process.argv.slice(2));
-  if (args.help) {
-    printHelp();
-    process.exit(0);
-  }
-  const contract = readGeneratedContractView();
-  const app = contract.apps?.find(candidate => candidate.id === args.appId);
-  if (!app) {
-    throw new Error(`Unknown app in UltraModern config: ${args.appId}`);
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+      printHelp();
+      process.exit(0);
+    }
+    const contract = await readGeneratedContractView();
+    const app = contract.apps?.find(candidate => candidate.id === args.appId);
+    if (!app) {
+      throw new Error(`Unknown app in UltraModern config: ${args.appId}`);
+    }
+    await generatePublicSurfaceAssets(app, args.target, args.requirePublicOrigin);
+  } catch (error) {
+    process.stderr.write(`[public-surface] ${error.message}\n`);
+    process.exitCode = 1;
   }
-  await generatePublicSurfaceAssets(app, args.target, args.requirePublicOrigin);
-} catch (error) {
-  process.stderr.write(`[public-surface] ${error.message}\n`);
-  process.exitCode = 1;
 }