@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

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

@@ -18,16 +18,23 @@ import {
   validateUltramodernBuildArtifact,
 } from '@modern-js/backend-federation-contracts';
 
-export const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+export const REFERENCE_TOPOLOGY_PATH = 'topology/reference-topology.json';
+export const DEVELOPMENT_OVERLAY_PATH =
+  'topology/local-overlays/development.json';
 
-export type CompactApp = {
+export type TopologyApp = {
   id?: unknown;
+  domain?: unknown;
   kind?: unknown;
   path?: unknown;
   package?: unknown;
-  port?: unknown;
+  portEnv?: unknown;
+  cloudflare?: { publicUrlEnv?: unknown };
   api?: {
-    prefix?: unknown;
+    bff?: { prefix?: unknown };
+    protocol?: unknown;
+    rpcPath?: unknown;
+    rpcSerialization?: unknown;
     stem?: unknown;
   };
   moduleFederation?: {
@@ -57,20 +64,28 @@ export type CompactApp = {
     packageName?: unknown;
     version?: unknown;
   };
-  serverExecution?: {
-    node?: {
-      remoteName?: unknown;
-      manifestUrl?: unknown;
-      containerEntry?: unknown;
-      remoteType?: unknown;
-    };
-  };
 };
 
-export type CompactConfig = {
-  topology?: {
-    apps?: CompactApp[];
-  };
+export type DevelopmentOverlay = {
+  ports?: Record<string, unknown>;
+  manifests?: Record<string, unknown>;
+  serverExecution?: Record<
+    string,
+    {
+      node?: {
+        remoteName?: unknown;
+        manifestUrl?: unknown;
+        containerEntry?: unknown;
+        remoteType?: unknown;
+      };
+    }
+  >;
+};
+
+export type ReferenceTopology = {
+  shell?: TopologyApp;
+  shells?: TopologyApp[];
+  verticals?: TopologyApp[];
 };
 
 export type BackendFederationApp = {
@@ -84,13 +99,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;
@@ -169,11 +186,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,11 +199,34 @@ const createBackendName = (app: CompactApp, id: string) => {
   return mfName ? `${mfName}Backend` : `vertical${toPascalCase(id)}Backend`;
 };
 
+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 findWorkspaceRoot = (appDirectory: string) => {
   let current = appDirectory;
 
   while (true) {
-    if (existsSync(path.join(current, COMPACT_CONFIG_PATH))) {
+    if (existsSync(path.join(current, REFERENCE_TOPOLOGY_PATH))) {
       return current;
     }
 
@@ -240,50 +279,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 +410,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 +435,18 @@ export const createAppFromCompactMetadata = (
     id,
     directory,
     packageName,
+    version,
     port,
     apiPrefix,
+    apiProtocol,
+    rpcPath,
     apiStem,
     backendName,
     manifestUrl,
     containerEntry,
     remoteType,
     uiManifestUrl,
-    compactDeliveryUnit,
+    topologyDeliveryUnit,
   };
 };
 
@@ -335,22 +454,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
-    : [];
-
-  for (const app of apps) {
-    const resolved = createAppFromCompactMetadata(
+  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 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

@@ -16,10 +16,10 @@ import {
 import {
   type BackendFederationApp,
   buildArtifactPathFor,
-  COMPACT_CONFIG_PATH,
   createStampedDeliveryUnit,
   findBackendFederationApp,
   findWorkspaceRoot,
+  REFERENCE_TOPOLOGY_PATH,
   readBuildIdentity,
   resolveWorkspaceSourceRevision,
 } from './config';
@@ -58,13 +58,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 +72,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,31 +89,45 @@ 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;
+    topologyDeliveryUnit?.buildMarker ?? buildIdentity.buildVersion;
   const sourceRevision = await resolveWorkspaceSourceRevision(workspaceRoot);
   const buildVersion =
     generationBuildMarker && unitId
@@ -123,11 +137,8 @@ export const emitBackendFederationArtifacts = async (
           workspaceRoot,
         }).buildMarker
       : undefined;
-  const packageName =
-    compactDeliveryUnit?.packageName ??
-    buildIdentity.packageName ??
-    app.packageName;
-  const version = compactDeliveryUnit?.version ?? buildIdentity.version;
+  const packageName = app.packageName;
+  const version = app.version;
   const deliveryUnit = createStampedDeliveryUnit({
     appId: app.id,
     unitId,

package/src/build-config/remote-address.ts

@@ -0,0 +1,31 @@
+import {
+  type BrowserManifestAddressOptions,
+  resolveBrowserManifestAddress,
+} from '@modern-js/surface-resolution';
+import { getBuildConfigEnvironment } from './build-environment';
+
+/** Adapt build environment leases and MF's name@URL syntax to discovery policy. */
+export function createRemoteManifestUrl(
+  options: BrowserManifestAddressOptions,
+): string {
+  const env = Object.fromEntries(
+    [
+      options.manifestEnv,
+      options.publicUrlEnv,
+      'MODERNJS_DEPLOY',
+      'ULTRAMODERN_CLOUDFLARE_WORKERS_DEV_SUBDOMAIN',
+      'ULTRAMODERN_CLOUDFLARE_REQUIRE_PUBLIC_URLS',
+    ].map(name => [name, getBuildConfigEnvironment(name)]),
+  );
+  const address = resolveBrowserManifestAddress(
+    env,
+    options,
+    getBuildConfigEnvironment('NODE_ENV') ?? 'production',
+  );
+  if (!address.ok)
+    throw new Error(`Remote ${options.mfName}: ${address.reason}`);
+  return (
+    env[options.manifestEnv]?.trim() ||
+    `${options.mfName}@${address.manifestUrl}`
+  );
+}

package/src/cloudflare/delivery-unit.ts

@@ -10,7 +10,7 @@ import { fs as fse } from '@modern-js/utils';
 import { resolveUltramodernReleaseIdentity } from '../release-identity';
 import { isRecord } from './utils';
 
-const COMPACT_CONFIG_PATH = '.modernjs/ultramodern.json';
+const TOPOLOGY_PATH = 'topology/reference-topology.json';
 
 export type DeliveryUnitStamp = DeliveryUnitIdentity & {
   surfaces: {
@@ -19,7 +19,7 @@ export type DeliveryUnitStamp = DeliveryUnitIdentity & {
   };
 };
 
-type CompactAppResolution = {
+type TopologyAppResolution = {
   app?: Record<string, unknown>;
   workspaceRoot: string;
 };
@@ -30,7 +30,7 @@ const findWorkspaceRoot = async (
   let current = path.resolve(appDirectory);
 
   for (;;) {
-    if (await fse.pathExists(path.join(current, COMPACT_CONFIG_PATH))) {
+    if (await fse.pathExists(path.join(current, TOPOLOGY_PATH))) {
       return current;
     }
 
@@ -60,34 +60,32 @@ const stampReleaseIdentity = (
   };
 };
 
-const resolveCompactApp = async (
+const resolveTopologyApp = async (
   appDirectory: string,
-): Promise<CompactAppResolution | undefined> => {
+): Promise<TopologyAppResolution | undefined> => {
   const workspaceRoot = await findWorkspaceRoot(appDirectory);
   if (!workspaceRoot) {
     return undefined;
   }
 
-  let compactConfig: unknown;
-  try {
-    compactConfig = await fse.readJSON(
-      path.join(workspaceRoot, COMPACT_CONFIG_PATH),
+  const topology: unknown = await fse.readJSON(
+    path.join(workspaceRoot, TOPOLOGY_PATH),
+  );
+  if (
+    !isRecord(topology) ||
+    !isRecord(topology.shell) ||
+    !Array.isArray(topology.verticals) ||
+    (topology.shells !== undefined && !Array.isArray(topology.shells))
+  ) {
+    throw new Error(
+      '[cloudflare-delivery-unit] Invalid declared reference topology.',
     );
-  } catch {
-    return { workspaceRoot };
-  }
-
-  if (!isRecord(compactConfig)) {
-    return { workspaceRoot };
-  }
-
-  const topology = isRecord(compactConfig.topology)
-    ? compactConfig.topology
-    : undefined;
-  const apps = Array.isArray(topology?.apps) ? topology.apps : undefined;
-  if (!apps) {
-    return { app: compactConfig, workspaceRoot };
   }
+  const apps = [
+    topology.shell,
+    ...topology.verticals,
+    ...(Array.isArray(topology.shells) ? topology.shells : []),
+  ];
 
   const resolvedAppDirectory = path.resolve(appDirectory);
   const app = apps.find(candidate => {
@@ -101,8 +99,13 @@ const resolveCompactApp = async (
         resolvedAppDirectory
     );
   });
+  if (!isRecord(app)) {
+    throw new Error(
+      `[cloudflare-delivery-unit] ${appDirectory} is missing from the declared reference topology.`,
+    );
+  }
   return {
-    ...(isRecord(app) ? { app } : {}),
+    app,
     workspaceRoot,
   };
 };
@@ -126,23 +129,26 @@ const createDeliveryUnitStamp = (
 
 /**
  * Resolve the delivery-unit record declared for this app by the workspace
- * compact config (`.modernjs/ultramodern.json`). This is the topology source
+ * reference topology. This is the topology source
  * of truth the Cloudflare worker snapshot is verified against.
  */
 export const resolveTopologyDeliveryUnit = async (
   appDirectory: string,
 ): Promise<DeliveryUnitStamp | undefined> => {
-  const resolved = await resolveCompactApp(appDirectory);
+  const resolved = await resolveTopologyApp(appDirectory);
   if (!resolved?.app) {
     return undefined;
   }
   const identity = toDeliveryUnitIdentity(resolved.app.deliveryUnit);
-  return identity
-    ? createDeliveryUnitStamp(
-        stampReleaseIdentity(identity, resolved.workspaceRoot),
-        resolved.app,
-      )
-    : undefined;
+  if (!identity) {
+    throw new Error(
+      '[cloudflare-delivery-unit] Declared app is missing a valid delivery-unit identity.',
+    );
+  }
+  return createDeliveryUnitStamp(
+    stampReleaseIdentity(identity, resolved.workspaceRoot),
+    resolved.app,
+  );
 };
 
 /**
@@ -170,7 +176,7 @@ export const resolveWorkerDeliveryUnitStamp = async (
   if (!identity) {
     return undefined;
   }
-  const resolved = await resolveCompactApp(appDirectory);
+  const resolved = await resolveTopologyApp(appDirectory);
   if (resolved) {
     identity = stampReleaseIdentity(identity, resolved.workspaceRoot);
   }