@bleedingdev/modern-js-create 3.4.0-ultramodern.9 → 3.5.0-ultramodern.1

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

@@ -4,18 +4,255 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const workspaceRoot = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-);
-const contractPath = path.join(
-  workspaceRoot,
-  '.modernjs/ultramodern-generated-contract.json',
+  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
+    path.join(path.dirname(fileURLToPath(import.meta.url)), '..'),
 );
+const compactConfigPath = path.join(workspaceRoot, '.modernjs/ultramodern.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`,
+    },
+  ];
+}
+
+function createPublicRoutes(app) {
+  return createRouteOwnedEntries(app)
+    .filter(route => route.public && route.indexable)
+    .map(route => ({
+      canonicalPath: route.canonicalPath,
+      id: route.id,
+      localisedPaths: route.localisedPaths,
+      namespace: route.namespace,
+      ownerAppId: route.ownerAppId,
+      descriptionKey: route.descriptionKey,
+      titleKey: route.titleKey,
+    }));
+}
+
+function createPublicSurface(app) {
+  const publicRoutes = createPublicRoutes(app);
+  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',
+    outputRoot: 'dist/public',
+    cloudflareOutputRoot: '.output/public',
+    privateRoutePolicy: 'omit-from-generated-public-surface',
+    files:
+      publicRoutes.length > 0
+        ? ['robots.txt', 'sitemap.xml', 'site.webmanifest']
+        : ['robots.txt'],
+    omittedByDefault: ['api-catalog.json', 'llms.txt', 'security.txt'],
+    languages: ['en', 'cs'],
+    contentExpansion: {
+      authoring: 'route-owned-esm-provider',
+      defaultProviderFile: 'route.sitemap.mjs',
+      entryExport: 'default-or-entries',
+      paramsSource: 'params-or-localeParams',
+      draftPolicy: 'omit-draft-by-default',
+      indexablePolicy: 'omit-indexable-false',
+      lifecycle: 'executed-during-public-surface-generation',
+    },
+    contentSources: [],
+    publicRoutes,
+    routeEntries: [],
+    concreteUrlPaths: [],
+  };
+
+  return app.routes?.publicSurface &&
+    typeof app.routes.publicSurface === 'object'
+    ? {
+        ...basePublicSurface,
+        ...app.routes.publicSurface,
+      }
+    : 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)
+    : [];
+
+  return {
+    sourcePath: compactConfigPath,
+    apps: apps.map(app => ({
+      ...app,
+      deploy: {
+        cloudflare: createCloudflareDeploy(config, app),
+      },
+      routes: {
+        publicSurface: createPublicSurface(app),
+      },
+    })),
+  };
+}
+
+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,
@@ -52,7 +289,7 @@ function parseArgs(argv) {
 
 function printHelp() {
   process.stdout.write(`Usage:
-  node scripts/generate-public-surface-assets.mjs --app shell-super-app [--target dist|cloudflare] [--require-public-origin]
+  node scripts/generate-public-surface-assets.mts --app shell-super-app [--target dist|cloudflare] [--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
@@ -517,10 +754,10 @@ try {
     printHelp();
     process.exit(0);
   }
-  const contract = readJson(contractPath);
+  const contract = readGeneratedContractView();
   const app = contract.apps?.find(candidate => candidate.id === args.appId);
   if (!app) {
-    throw new Error(`Unknown app in generated contract: ${args.appId}`);
+    throw new Error(`Unknown app in UltraModern config: ${args.appId}`);
   }
   await generatePublicSurfaceAssets(app, args.target, args.requirePublicOrigin);
 } catch (error) {

package/templates/workspace-scripts/proof-cloudflare-version.mjs

@@ -1,17 +1,15 @@
 #!/usr/bin/env node
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { validateApp } from './ultramodern-cloudflare-proof.mjs';
 
 const workspaceRoot = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-);
-const contractPath = path.join(
-  workspaceRoot,
-  '.modernjs/ultramodern-generated-contract.json',
+  process.env.ULTRAMODERN_WORKSPACE_ROOT ??
+    path.join(path.dirname(fileURLToPath(import.meta.url)), '..'),
 );
+const compactConfigPath = path.join(workspaceRoot, '.modernjs/ultramodern.json');
 const defaultOut = path.join(
   workspaceRoot,
   '.codex/reports/cloudflare-version-proof/public-url-proof.json',
@@ -21,6 +19,276 @@ function readJson(filePath) {
   return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
 
+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 toPascalCase(value) {
+  return toKebabCase(value)
+    .split('-')
+    .filter(Boolean)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+}
+
+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 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
+      : {};
+  const 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;
+
+  return {
+    id,
+    kind,
+    path: appPath,
+    packageSuffix,
+    domain,
+    mfName:
+      typeof moduleFederation.name === 'string'
+        ? moduleFederation.name
+        : kind === 'shell'
+          ? 'shellSuperApp'
+          : `vertical${toPascalCase(domain ?? id)}`,
+    api,
+  };
+}
+
+function createBuildMarker(scope, app) {
+  return crypto
+    .createHash('sha256')
+    .update(`${scope}:${app.packageSuffix}:${app.id}:0.1.0`)
+    .digest('hex')
+    .slice(0, 16);
+}
+
+function createCloudflareSecurity() {
+  return {
+    enabled: true,
+    headers: {
+      referrerPolicy: 'strict-origin-when-cross-origin',
+      contentTypeOptions: 'nosniff',
+      permissionsPolicy:
+        'camera=(), geolocation=(), microphone=(), payment=(), usb=()',
+    },
+    contentSecurityPolicy: {
+      mode: 'report-only',
+      directives: {
+        'base-uri': [`'self'`],
+        'connect-src': [`'self'`, 'https:', 'http:', 'wss:', 'ws:'],
+        'default-src': [`'self'`],
+        'font-src': [`'self'`, 'data:', 'https:', 'http:'],
+        'form-action': [`'self'`],
+        'frame-ancestors': [`'self'`],
+        'img-src': [`'self'`, 'data:', 'blob:', 'https:', 'http:'],
+        'manifest-src': [`'self'`, 'https:', 'http:'],
+        'object-src': [`'none'`],
+        'script-src': [
+          `'self'`,
+          `'unsafe-inline'`,
+          `'unsafe-eval'`,
+          'https:',
+          'http:',
+          'blob:',
+        ],
+        'style-src': [`'self'`, `'unsafe-inline'`, 'https:', 'http:'],
+        'worker-src': [`'self'`, 'blob:'],
+      },
+      reason:
+        'Report-only by default so Cloudflare Module Federation SSR can prove remote script, style, and connect compatibility before enforcement.',
+    },
+    noindex: {
+      workersDev: true,
+      localhost: true,
+      previewHostnames: [],
+    },
+  };
+}
+
+function createQualityGates() {
+  return {
+    publicRoutes: {
+      requireSitemapWhenPresent: true,
+      requireRobotsSitemapConsistency: true,
+      requireWebManifestWhenPresent: true,
+    },
+    statusCodes: {
+      notFoundRoute: '/__ultramodern-smoke-missing/nope',
+      unknownRouteStatus: 404,
+    },
+    indexing: {
+      previewNoindex: true,
+      productionPublicRoutesIndexable: true,
+    },
+    assets: {
+      cssPreloadRequired: true,
+      cssResponseRequired: true,
+      cacheControlRequiredForCss: true,
+      sourcemapsPubliclyReferenced: false,
+    },
+    budgets: {
+      ssrHtmlMaxBytes: 250_000,
+      mfManifestMaxBytes: 500_000,
+      localeJsonMaxBytes: 100_000,
+      sitemapXmlMaxBytes: 500_000,
+      cssAssetMaxBytes: 750_000,
+    },
+    csp: {
+      finalMode: 'report-only-dogfood',
+      decision:
+        'Report-only remains the generated final mode until public smoke proof records MF SSR script/style/connect compatibility for the deployed surface.',
+    },
+  };
+}
+
+function createPublicHead() {
+  return {
+    alternates: {
+      hreflang: ['en', 'cs'],
+      xDefault: 'en',
+    },
+  };
+}
+
+function createPublicSurface() {
+  return {
+    publicRoutes: [],
+    routeEntries: [],
+    contentSources: [],
+    concreteUrlPaths: [],
+  };
+}
+
+function createCloudflareRoutes(app) {
+  return {
+    ssr: '/en',
+    mfManifest: '/mf-manifest.json',
+    locale: `/locales/en/${appNamespace(app)}.json`,
+    ...(app.api
+      ? {
+          apiReadiness: `${app.api.prefix}/${app.api.stem}/readiness`,
+        }
+      : {}),
+  };
+}
+
+function createContractApp(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 {
+    id: app.id,
+    deploy: {
+      cloudflare: {
+        workerName: `${toKebabCase(packageScope)}-${app.packageSuffix}`.slice(
+          0,
+          63,
+        ),
+        publicUrlEnv: `ULTRAMODERN_PUBLIC_URL_${toEnvSegment(app.id)}`,
+        compatibilityDate,
+        compatibilityFlags: ['nodejs_compat', 'global_fetch_strictly_public'],
+        routes: createCloudflareRoutes(app),
+        security: createCloudflareSecurity(),
+        qualityGates: createQualityGates(),
+      },
+    },
+    i18n: {
+      namespace: appNamespace(app),
+    },
+    marker: {
+      appId: app.id,
+      build: createBuildMarker(packageScope, app),
+    },
+    routes: {
+      publicHead: createPublicHead(),
+      publicSurface: createPublicSurface(),
+    },
+    styling: {
+      federation: {
+        rootSelector: `[data-app-id="${app.id}"]`,
+      },
+    },
+  };
+}
+
+function synthesizeContractFromCompactConfig(config) {
+  const apps = Array.isArray(config.topology?.apps)
+    ? config.topology.apps.map(normalizeCompactApp)
+    : [];
+
+  return {
+    sourcePath: compactConfigPath,
+    apps: apps.map(app => createContractApp(config, app)),
+  };
+}
+
+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,
@@ -50,7 +318,7 @@ function parseArgs(argv) {
 
 function printHelp() {
   process.stdout.write(`Usage:
-  node scripts/proof-cloudflare-version.mjs [--app workspace] [--out evidence.json] [--require-public-urls]
+  node scripts/proof-cloudflare-version.mts [--app workspace] [--out evidence.json] [--require-public-urls]
 
 Set each app's public URL using the contract env key, for example:
   ULTRAMODERN_PUBLIC_URL_WORKSPACE=https://workspace.example.workers.dev
@@ -70,7 +338,7 @@ async function main(argv = process.argv.slice(2)) {
     return 0;
   }
 
-  const contract = readJson(contractPath);
+  const contract = readGeneratedContractView();
   const apps = args.appId
     ? contract.apps.filter(app => app.id === args.appId)
     : contract.apps;
@@ -101,7 +369,7 @@ async function main(argv = process.argv.slice(2)) {
     schemaVersion: 1,
     generatedAt: new Date().toISOString(),
     status: results.length > 0 ? 'pass' : 'skipped',
-    contractPath,
+    contractPath: contract.sourcePath ?? compactConfigPath,
     results,
     skipped,
   };

package/templates/workspace-scripts/ultramodern-cloudflare-proof.mjs

@@ -6,6 +6,20 @@ function normalizeUrlWithTrailingSlash(url) {
   return url.endsWith('/') ? url : `${url}/`;
 }
 
+function resolveModuleFederationPublicPath(publicPath, manifestUrl) {
+  if (typeof publicPath !== 'string' || publicPath.trim().length === 0) {
+    return undefined;
+  }
+
+  try {
+    return normalizeUrlWithTrailingSlash(
+      new URL(publicPath.trim(), manifestUrl).toString(),
+    );
+  } catch {
+    return undefined;
+  }
+}
+
 async function fetchText(url) {
   const response = await fetch(url);
   return {
@@ -464,7 +478,8 @@ async function validateSsrHead(evidence, app, publicUrl, ssrRoute, ssr) {
 async function validateNotFound(evidence, app, publicUrl) {
   const qualityGates = app.deploy?.cloudflare?.qualityGates ?? {};
   const notFoundRoute =
-    qualityGates.statusCodes?.notFoundRoute ?? '/__ultramodern-smoke-missing';
+    qualityGates.statusCodes?.notFoundRoute ??
+    '/__ultramodern-smoke-missing/nope';
   const expectedStatus = qualityGates.statusCodes?.unknownRouteStatus ?? 404;
   const response = await fetchText(joinUrl(publicUrl, notFoundRoute));
   evidence.assertions.push({
@@ -721,7 +736,8 @@ async function validateModuleFederationManifestEvidence(evidence, app, publicUrl
   const budgets = qualityGates.budgets ?? {};
 
   const manifestRoute = routes.mfManifest ?? '/mf-manifest.json';
-  const manifest = await fetchText(joinUrl(publicUrl, manifestRoute));
+  const manifestUrl = joinUrl(publicUrl, manifestRoute);
+  const manifest = await fetchText(manifestUrl);
   const manifestJson = parseMaybeJson(manifest.body);
   evidence.assertions.push({
     type: 'mf-manifest',
@@ -754,17 +770,26 @@ async function validateModuleFederationManifestEvidence(evidence, app, publicUrl
     manifest.accessControlAllowOrigin === '*',
     `${app.id} MF manifest is missing Cloudflare CORS headers`,
   );
-  const expectedPublicPath = normalizeUrlWithTrailingSlash(publicUrl);
+  const expectedPublicPath = normalizeUrlWithTrailingSlash(
+    new URL('.', manifestUrl).toString(),
+  );
   const manifestPublicPath = manifestJson?.metaData?.publicPath;
+  const resolvedPublicPath = resolveModuleFederationPublicPath(
+    manifestPublicPath,
+    manifestUrl,
+  );
   evidence.assertions.push({
     type: 'mf-manifest-public-path',
     expected: expectedPublicPath,
     actual: manifestPublicPath,
-    status: manifestPublicPath === expectedPublicPath ? 'pass' : 'fail',
+    resolved: resolvedPublicPath,
+    status: resolvedPublicPath === expectedPublicPath ? 'pass' : 'fail',
   });
   assert(
-    manifestPublicPath === expectedPublicPath,
-    `${app.id} MF manifest publicPath must resolve remote assets from ${expectedPublicPath}`,
+    resolvedPublicPath === expectedPublicPath,
+    `${app.id} MF manifest publicPath must resolve remote assets from ${expectedPublicPath}; got ${String(
+      manifestPublicPath,
+    )}`,
   );
 }
 
@@ -815,13 +840,13 @@ async function validateI18nEvidence(evidence, app, publicUrl, routes) {
 }
 
 async function validateReadinessEvidence(evidence, app, publicUrl, routes) {
-  if (routes.effectReadiness) {
-    const readiness = await fetchText(joinUrl(publicUrl, routes.effectReadiness));
+  if (routes.apiReadiness) {
+    const readiness = await fetchText(joinUrl(publicUrl, routes.apiReadiness));
     const readinessJson = parseMaybeJson(readiness.body);
     const apiMarker = markerFromJson(readinessJson);
     evidence.assertions.push({
       type: 'api-marker',
-      route: routes.effectReadiness,
+      route: routes.apiReadiness,
       expected: app.marker?.build,
       actual: apiMarker,
       status: readiness.ok && apiMarker === app.marker?.build ? 'pass' : 'fail',
@@ -848,4 +873,4 @@ async function validateApp(app, publicUrl) {
   return evidence;
 }
 
-export { validateApp };
+export { resolveModuleFederationPublicPath, validateApp };