@vercel/microfrontends 1.1.1-canary.2 → 1.1.1-canary.4

package/dist/utils/mfe-port.cjs

@@ -33,12 +33,12 @@ __export(mfe_port_exports, {
   mfePort: () => mfePort
 });
 module.exports = __toCommonJS(mfe_port_exports);
-var import_node_path10 = __toESM(require("path"), 1);
-var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
 
 // src/config/microfrontends/server/index.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path9 = require("path");
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path8 = require("path");
 
 // src/config/overrides/constants.ts
 var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
@@ -177,19 +177,177 @@ function getConfigStringFromEnv() {
   return config;
 }
 
-// src/config/microfrontends-config/isomorphic/index.ts
+// src/config/schema/utils/is-default-app.ts
+function isDefaultApp(a) {
+  return !("routing" in a);
+}
+
+// src/config/microfrontends/utils/find-repository-root.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var GIT_DIRECTORY = ".git";
+function hasGitDirectory(dir) {
+  const gitPath = import_node_path.default.join(dir, GIT_DIRECTORY);
+  return import_node_fs.default.existsSync(gitPath) && import_node_fs.default.statSync(gitPath).isDirectory();
+}
+function hasPnpmWorkspaces(dir) {
+  return import_node_fs.default.existsSync(import_node_path.default.join(dir, "pnpm-workspace.yaml"));
+}
+function findRepositoryRoot(startDir) {
+  if (process.env.NX_WORKSPACE_ROOT) {
+    return process.env.NX_WORKSPACE_ROOT;
+  }
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== import_node_path.default.parse(currentDir).root) {
+    if (hasGitDirectory(currentDir) || hasPnpmWorkspaces(currentDir)) {
+      return currentDir;
+    }
+    currentDir = import_node_path.default.dirname(currentDir);
+  }
+  throw new Error(
+    "Repository root not found. Specify the root of the repository with the `repository.root` option."
+  );
+}
+
+// src/config/microfrontends/utils/find-default-package.ts
+var import_node_path2 = require("path");
+var import_node_fs2 = require("fs");
 var import_jsonc_parser = require("jsonc-parser");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
 
-// src/config/schema/utils/is-main-config.ts
-function isMainConfig(c) {
-  return !("partOf" in c);
+// src/config/constants.ts
+var CONFIGURATION_FILENAMES = [
+  "microfrontends.jsonc",
+  "microfrontends.json"
+];
+
+// src/config/microfrontends/utils/find-default-package.ts
+var configCache = {};
+function findDefaultMicrofrontendsPackages({
+  repositoryRoot,
+  applicationName
+}) {
+  try {
+    const microfrontendsJsonPaths = import_fast_glob.default.globSync(
+      `**/{${CONFIGURATION_FILENAMES.join(",")}}`,
+      {
+        cwd: repositoryRoot,
+        absolute: true,
+        onlyFiles: true,
+        followSymbolicLinks: false,
+        ignore: ["**/node_modules/**", "**/.git/**"]
+      }
+    );
+    const matchingPaths = [];
+    for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
+      try {
+        const microfrontendsJsonContent = (0, import_node_fs2.readFileSync)(
+          microfrontendsJsonPath,
+          "utf-8"
+        );
+        const microfrontendsJson = (0, import_jsonc_parser.parse)(microfrontendsJsonContent);
+        if (microfrontendsJson.applications[applicationName]) {
+          matchingPaths.push(microfrontendsJsonPath);
+        }
+      } catch (error) {
+      }
+    }
+    if (matchingPaths.length > 1) {
+      throw new Error(
+        `Found multiple default applications referencing "${applicationName}" in the repository, but only one is allowed.
+${matchingPaths.join("\n  \u2022 ")}`
+      );
+    }
+    if (matchingPaths.length === 0) {
+      throw new Error(
+        `Could not find default application with "applications.${applicationName}"`
+      );
+    }
+    const [packageJsonPath] = matchingPaths;
+    return (0, import_node_path2.dirname)(packageJsonPath);
+  } catch (error) {
+    return null;
+  }
+}
+function findDefaultMicrofrontendsPackage(opts) {
+  const cacheKey = `${opts.repositoryRoot}-${opts.applicationName}`;
+  if (configCache[cacheKey]) {
+    return configCache[cacheKey];
+  }
+  const result = findDefaultMicrofrontendsPackages(opts);
+  if (!result) {
+    throw new Error(
+      "Error trying to resolve the main microfrontends configuration"
+    );
+  }
+  configCache[cacheKey] = result;
+  return result;
 }
 
-// src/config/schema/utils/is-default-app.ts
-function isDefaultApp(a) {
-  return !("routing" in a);
+// src/config/microfrontends/utils/is-monorepo.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+function isMonorepo({
+  repositoryRoot
+}) {
+  try {
+    if (import_node_fs3.default.existsSync(import_node_path3.default.join(repositoryRoot, "pnpm-workspace.yaml"))) {
+      return true;
+    }
+    if (import_node_fs3.default.existsSync(import_node_path3.default.join(repositoryRoot, "vlt-workspaces.json"))) {
+      return true;
+    }
+    if (process.env.NX_WORKSPACE_ROOT === import_node_path3.default.resolve(repositoryRoot)) {
+      return true;
+    }
+    const packageJsonPath = import_node_path3.default.join(repositoryRoot, "package.json");
+    if (!import_node_fs3.default.existsSync(packageJsonPath)) {
+      return false;
+    }
+    const packageJson = JSON.parse(
+      import_node_fs3.default.readFileSync(packageJsonPath, "utf-8")
+    );
+    return packageJson.workspaces !== void 0;
+  } catch (error) {
+    console.error("Error determining if repository is a monorepo", error);
+    return false;
+  }
+}
+
+// src/config/microfrontends/utils/find-package-root.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var PACKAGE_JSON = "package.json";
+function findPackageRoot(startDir) {
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== import_node_path4.default.parse(currentDir).root) {
+    const pkgJsonPath = import_node_path4.default.join(currentDir, PACKAGE_JSON);
+    if (import_node_fs4.default.existsSync(pkgJsonPath)) {
+      return currentDir;
+    }
+    currentDir = import_node_path4.default.dirname(currentDir);
+  }
+  throw new Error(
+    "Package root not found. Specify the root of the package with the `package.root` option."
+  );
 }
 
+// src/config/microfrontends/utils/find-config.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path5 = require("path");
+function findConfig({ dir }) {
+  for (const filename of CONFIGURATION_FILENAMES) {
+    const maybeConfig = (0, import_node_path5.join)(dir, filename);
+    if (import_node_fs5.default.existsSync(maybeConfig)) {
+      return maybeConfig;
+    }
+  }
+  return null;
+}
+
+// src/config/microfrontends-config/isomorphic/index.ts
+var import_jsonc_parser2 = require("jsonc-parser");
+
 // src/config/microfrontends-config/client/index.ts
 var import_path_to_regexp = require("path-to-regexp");
 var MicrofrontendConfigClient = class {
@@ -258,6 +416,10 @@ var MicrofrontendConfigClient = class {
 
 // src/config/microfrontends-config/isomorphic/validation.ts
 var import_path_to_regexp2 = require("path-to-regexp");
+var LIST_FORMATTER = new Intl.ListFormat("en", {
+  style: "long",
+  type: "conjunction"
+});
 var validateConfigPaths = (applicationConfigsById) => {
   if (!applicationConfigsById) {
     return;
@@ -390,15 +552,15 @@ var validateConfigDefaultApplication = (applicationConfigsById) => {
   if (!applicationConfigsById) {
     return;
   }
-  const applicationsWithRouting = Object.entries(applicationConfigsById).filter(
-    ([, app]) => !isDefaultApp(app)
-  );
-  const applicationsWithRoutingNames = applicationsWithRouting.map(
-    ([key]) => key
+  const applicationsWithoutRouting = Object.entries(
+    applicationConfigsById
+  ).filter(([, app]) => isDefaultApp(app));
+  const numApplicationsWithoutRouting = applicationsWithoutRouting.reduce(
+    (acc) => {
+      return acc + 1;
+    },
+    0
   );
-  const numApplications = Object.keys(applicationConfigsById).length;
-  const numApplicationsWithRouting = applicationsWithRoutingNames.length;
-  const numApplicationsWithoutRouting = numApplications - numApplicationsWithRouting;
   if (numApplicationsWithoutRouting === 0) {
     throw new MicrofrontendError(
       "No default application found. At least one application needs to be the default by omitting routing.",
@@ -406,8 +568,11 @@ var validateConfigDefaultApplication = (applicationConfigsById) => {
     );
   }
   if (numApplicationsWithoutRouting > 1) {
+    const applicationNamesMissingRouting = applicationsWithoutRouting.map(
+      ([name]) => name
+    );
     throw new MicrofrontendError(
-      `Only one application can omit "routing". Found ${applicationsWithRoutingNames.length - Object.keys(applicationConfigsById).length > 1}.`,
+      `All applications except for the default app must contain the "routing" field. Applications that are missing routing: ${LIST_FORMATTER.format(applicationNamesMissingRouting)}.`,
       { type: "config", subtype: "multiple_default_applications" }
     );
   }
@@ -718,42 +883,28 @@ var MicrofrontendConfigIsomorphic = class {
   constructor({
     config,
     overrides,
-    meta,
     opts
   }) {
     this.childApplications = {};
     MicrofrontendConfigIsomorphic.validate(config, opts);
     const disableOverrides = config.options?.disableOverrides ?? config.options?.vercel?.disableOverrides ?? false;
     this.overrides = overrides && !disableOverrides ? overrides : void 0;
-    this.isMainConfig = isMainConfig(config);
-    if (isMainConfig(config)) {
-      for (const [appId, appConfig] of Object.entries(config.applications)) {
-        const appOverrides = !disableOverrides ? this.overrides?.applications[appId] : void 0;
-        if (isDefaultApp(appConfig)) {
-          this.defaultApplication = new DefaultApplication(appId, {
-            app: appConfig,
-            overrides: appOverrides
-          });
-        } else {
-          this.childApplications[appId] = new ChildApplication(appId, {
-            app: appConfig,
-            overrides: appOverrides
-          });
-        }
-      }
-    } else {
-      this.partOf = config.partOf;
-      const appOverrides = !disableOverrides ? this.overrides?.applications[meta.fromApp] : void 0;
-      this.childApplications[meta.fromApp] = new ChildApplication(
-        meta.fromApp,
-        {
-          // we don't know routing because we're not in the main config
-          app: { routing: [] },
+    let defaultApplication;
+    for (const [appId, appConfig] of Object.entries(config.applications)) {
+      const appOverrides = !disableOverrides ? this.overrides?.applications[appId] : void 0;
+      if (isDefaultApp(appConfig)) {
+        defaultApplication = new DefaultApplication(appId, {
+          app: appConfig,
           overrides: appOverrides
-        }
-      );
+        });
+      } else {
+        this.childApplications[appId] = new ChildApplication(appId, {
+          app: appConfig,
+          overrides: appOverrides
+        });
+      }
     }
-    if (isMainConfig(config) && !this.defaultApplication) {
+    if (!defaultApplication) {
       throw new MicrofrontendError(
         "Could not find default application in microfrontends configuration",
         {
@@ -762,34 +913,30 @@ var MicrofrontendConfigIsomorphic = class {
         }
       );
     }
+    this.defaultApplication = defaultApplication;
     this.config = config;
     this.options = config.options;
     this.serialized = {
       config,
-      overrides,
-      meta
+      overrides
     };
   }
   static validate(config, opts) {
     const skipValidation = opts?.skipValidation ?? [];
-    const c = typeof config === "string" ? (0, import_jsonc_parser.parse)(config) : config;
-    if (isMainConfig(c)) {
-      validateConfigPaths(c.applications);
-      validateConfigDefaultApplication(c.applications);
-      if (!skipValidation.includes("deprecatedFields")) {
-        validateDeprecatedFields(c);
-      }
+    const c = typeof config === "string" ? (0, import_jsonc_parser2.parse)(config) : config;
+    validateConfigPaths(c.applications);
+    validateConfigDefaultApplication(c.applications);
+    if (!skipValidation.includes("deprecatedFields")) {
+      validateDeprecatedFields(c);
     }
     return c;
   }
   static fromEnv({
-    meta,
     cookies
   }) {
     return new MicrofrontendConfigIsomorphic({
-      config: (0, import_jsonc_parser.parse)(getConfigStringFromEnv()),
-      overrides: parseOverrides(cookies ?? []),
-      meta
+      config: (0, import_jsonc_parser2.parse)(getConfigStringFromEnv()),
+      overrides: parseOverrides(cookies ?? [])
     });
   }
   isOverridesDisabled() {
@@ -814,7 +961,7 @@ var MicrofrontendConfigIsomorphic = class {
     ].filter(Boolean);
   }
   getApplication(name) {
-    if (this.defaultApplication?.name === name || this.defaultApplication?.packageName === name) {
+    if (this.defaultApplication.name === name || this.defaultApplication.packageName === name) {
       return this.defaultApplication;
     }
     const app = this.childApplications[name] || Object.values(this.childApplications).find(
@@ -832,7 +979,7 @@ var MicrofrontendConfigIsomorphic = class {
     return app;
   }
   getApplicationByProjectId(projectId) {
-    if (this.defaultApplication?.projectId === projectId) {
+    if (this.defaultApplication.projectId === projectId) {
       return this.defaultApplication;
     }
     return Object.values(this.childApplications).find(
@@ -840,19 +987,9 @@ var MicrofrontendConfigIsomorphic = class {
     );
   }
   /**
-   * Returns the default application. This can throw if the default application
-   * is undefined ( )
+   * Returns the default application.
    */
   getDefaultApplication() {
-    if (!this.defaultApplication) {
-      throw new MicrofrontendError(
-        "Could not find default application in microfrontends configuration",
-        {
-          type: "application",
-          subtype: "not_found"
-        }
-      );
-    }
     return this.defaultApplication;
   }
   /**
@@ -879,11 +1016,9 @@ var MicrofrontendConfigIsomorphic = class {
         }
       ])
     );
-    if (this.defaultApplication) {
-      applications[this.defaultApplication.name] = {
-        default: true
-      };
-    }
+    applications[this.defaultApplication.name] = {
+      default: true
+    };
     return new MicrofrontendConfigClient({
       applications
     });
@@ -893,301 +1028,9 @@ var MicrofrontendConfigIsomorphic = class {
   }
 };
 
-// src/config/microfrontends-config/isomorphic/child.ts
-var MicrofrontendChildConfig = class extends MicrofrontendConfigIsomorphic {
-  constructor({
-    config,
-    overrides,
-    meta
-  }) {
-    super({ config, overrides, meta });
-    this.isMainConfig = false;
-    this.partOf = config.partOf;
-  }
-};
-
-// src/config/microfrontends-config/isomorphic/main.ts
-var MicrofrontendMainConfig = class extends MicrofrontendConfigIsomorphic {
-  constructor({
-    config,
-    overrides,
-    meta
-  }) {
-    super({ config, overrides, meta });
-    this.isMainConfig = true;
-    const disableOverrides = config.options?.disableOverrides ?? config.options?.vercel?.disableOverrides ?? false;
-    let defaultApplication;
-    for (const [appId, appConfig] of Object.entries(config.applications)) {
-      const appOverrides = !disableOverrides ? this.overrides?.applications[appId] : void 0;
-      if (isDefaultApp(appConfig)) {
-        defaultApplication = new DefaultApplication(appId, {
-          app: appConfig,
-          overrides: appOverrides
-        });
-      } else {
-        this.childApplications[appId] = new ChildApplication(appId, {
-          app: appConfig,
-          overrides: appOverrides
-        });
-      }
-    }
-    if (!defaultApplication) {
-      throw new MicrofrontendError(
-        "Could not find default application in microfrontends configuration",
-        {
-          type: "application",
-          subtype: "not_found"
-        }
-      );
-    }
-    this.defaultApplication = defaultApplication;
-  }
-};
-
-// src/config/microfrontends/isomorphic/index.ts
-var Microfrontends = class {
-  constructor({
-    config,
-    overrides,
-    meta
-  }) {
-    if (isMainConfig(config)) {
-      this.config = new MicrofrontendMainConfig({ config, overrides, meta });
-    } else {
-      this.config = new MicrofrontendChildConfig({ config, overrides, meta });
-    }
-  }
-  isChildConfig() {
-    return this.config instanceof MicrofrontendChildConfig;
-  }
-  static fromEnv({
-    cookies,
-    meta
-  }) {
-    const config = MicrofrontendConfigIsomorphic.fromEnv({
-      cookies,
-      meta
-    });
-    return new Microfrontends(config.serialize());
-  }
-};
-
-// src/config/microfrontends/utils/find-repository-root.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var GIT_DIRECTORY = ".git";
-function findRepositoryRoot(startDir) {
-  if (process.env.NX_WORKSPACE_ROOT) {
-    return process.env.NX_WORKSPACE_ROOT;
-  }
-  let currentDir = startDir || process.cwd();
-  while (currentDir !== import_node_path.default.parse(currentDir).root) {
-    const gitPath = import_node_path.default.join(currentDir, GIT_DIRECTORY);
-    if (import_node_fs.default.existsSync(gitPath) && import_node_fs.default.statSync(gitPath).isDirectory()) {
-      return currentDir;
-    }
-    currentDir = import_node_path.default.dirname(currentDir);
-  }
-  throw new Error(
-    "Repository root not found. Specify the root of the repository with the `repository.root` option."
-  );
-}
-
-// src/config/microfrontends/utils/find-package-path.ts
-var import_node_path2 = require("path");
-var import_node_fs2 = require("fs");
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var configCache = {};
-function findPackagePathWithGlob({
-  repositoryRoot,
-  name
-}) {
-  try {
-    const packageJsonPaths = import_fast_glob.default.globSync("**/package.json", {
-      cwd: repositoryRoot,
-      absolute: true,
-      onlyFiles: true,
-      followSymbolicLinks: false,
-      ignore: ["**/node_modules/**", "**/.git/**"]
-    });
-    const matchingPaths = [];
-    for (const packageJsonPath2 of packageJsonPaths) {
-      const packageJsonContent = (0, import_node_fs2.readFileSync)(packageJsonPath2, "utf-8");
-      const packageJson = JSON.parse(packageJsonContent);
-      if (packageJson.name === name) {
-        matchingPaths.push(packageJsonPath2);
-      }
-    }
-    if (matchingPaths.length > 1) {
-      throw new Error(
-        `Found multiple packages with the name "${name}" in the repository: ${matchingPaths.join(", ")}`
-      );
-    }
-    if (matchingPaths.length === 0) {
-      throw new Error(
-        `Could not find package with the name "${name}" in the repository`
-      );
-    }
-    const [packageJsonPath] = matchingPaths;
-    return (0, import_node_path2.dirname)(packageJsonPath);
-  } catch (error) {
-    return null;
-  }
-}
-function findPackagePath(opts) {
-  const cacheKey = `${opts.repositoryRoot}-${opts.name}`;
-  if (configCache[cacheKey]) {
-    return configCache[cacheKey];
-  }
-  const result = findPackagePathWithGlob(opts);
-  if (!result) {
-    throw new Error(
-      `Could not find package with the name "${opts.name}" in the repository`
-    );
-  }
-  configCache[cacheKey] = result;
-  return result;
-}
-
-// src/config/microfrontends/utils/find-default-package.ts
-var import_node_path3 = require("path");
-var import_node_fs3 = require("fs");
-var import_jsonc_parser2 = require("jsonc-parser");
-var import_fast_glob2 = __toESM(require("fast-glob"), 1);
-
-// src/config/constants.ts
-var CONFIGURATION_FILENAMES = [
-  "microfrontends.jsonc",
-  "microfrontends.json"
-];
-
-// src/config/microfrontends/utils/find-default-package.ts
-var configCache2 = {};
-function findDefaultMicrofrontendsPackages({
-  repositoryRoot,
-  applicationName
-}) {
-  try {
-    const microfrontendsJsonPaths = import_fast_glob2.default.globSync(
-      `**/{${CONFIGURATION_FILENAMES.join(",")}}`,
-      {
-        cwd: repositoryRoot,
-        absolute: true,
-        onlyFiles: true,
-        followSymbolicLinks: false,
-        ignore: ["**/node_modules/**", "**/.git/**"]
-      }
-    );
-    const matchingPaths = [];
-    for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
-      try {
-        const microfrontendsJsonContent = (0, import_node_fs3.readFileSync)(
-          microfrontendsJsonPath,
-          "utf-8"
-        );
-        const microfrontendsJson = (0, import_jsonc_parser2.parse)(microfrontendsJsonContent);
-        if (isMainConfig(microfrontendsJson) && microfrontendsJson.applications[applicationName]) {
-          matchingPaths.push(microfrontendsJsonPath);
-        }
-      } catch (error) {
-      }
-    }
-    if (matchingPaths.length > 1) {
-      throw new Error(
-        `Found multiple default applications referencing "${applicationName}" in the repository, this is not yet supported.
-${matchingPaths.join("\n  \u2022 ")}`
-      );
-    }
-    if (matchingPaths.length === 0) {
-      throw new Error(
-        `Could not find default application with "applications.${applicationName}"`
-      );
-    }
-    const [packageJsonPath] = matchingPaths;
-    return (0, import_node_path3.dirname)(packageJsonPath);
-  } catch (error) {
-    return null;
-  }
-}
-function findDefaultMicrofrontendsPackage(opts) {
-  const cacheKey = `${opts.repositoryRoot}-${opts.applicationName}`;
-  if (configCache2[cacheKey]) {
-    return configCache2[cacheKey];
-  }
-  const result = findDefaultMicrofrontendsPackages(opts);
-  if (!result) {
-    throw new Error(
-      "Error trying to resolve the main microfrontends configuration"
-    );
-  }
-  configCache2[cacheKey] = result;
-  return result;
-}
-
-// src/config/microfrontends/utils/is-monorepo.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-function isMonorepo({
-  repositoryRoot
-}) {
-  try {
-    if (import_node_fs4.default.existsSync(import_node_path4.default.join(repositoryRoot, "pnpm-workspace.yaml"))) {
-      return true;
-    }
-    if (import_node_fs4.default.existsSync(import_node_path4.default.join(repositoryRoot, "vlt-workspaces.json"))) {
-      return true;
-    }
-    if (process.env.NX_WORKSPACE_ROOT === import_node_path4.default.resolve(repositoryRoot)) {
-      return true;
-    }
-    const packageJsonPath = import_node_path4.default.join(repositoryRoot, "package.json");
-    if (!import_node_fs4.default.existsSync(packageJsonPath)) {
-      return false;
-    }
-    const packageJson = JSON.parse(
-      import_node_fs4.default.readFileSync(packageJsonPath, "utf-8")
-    );
-    return packageJson.workspaces !== void 0;
-  } catch (error) {
-    console.error("Error determining if repository is a monorepo", error);
-    return false;
-  }
-}
-
-// src/config/microfrontends/utils/find-package-root.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var PACKAGE_JSON = "package.json";
-function findPackageRoot(startDir) {
-  let currentDir = startDir || process.cwd();
-  while (currentDir !== import_node_path5.default.parse(currentDir).root) {
-    const pkgJsonPath = import_node_path5.default.join(currentDir, PACKAGE_JSON);
-    if (import_node_fs5.default.existsSync(pkgJsonPath)) {
-      return currentDir;
-    }
-    currentDir = import_node_path5.default.dirname(currentDir);
-  }
-  throw new Error(
-    "Package root not found. Specify the root of the package with the `package.root` option."
-  );
-}
-
-// src/config/microfrontends/utils/find-config.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path6 = require("path");
-function findConfig({ dir }) {
-  for (const filename of CONFIGURATION_FILENAMES) {
-    const maybeConfig = (0, import_node_path6.join)(dir, filename);
-    if (import_node_fs6.default.existsSync(maybeConfig)) {
-      return maybeConfig;
-    }
-  }
-  return null;
-}
-
 // src/config/microfrontends/utils/get-application-context.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 function getApplicationContext(opts) {
   if (opts?.appName) {
     return { name: opts.appName };
@@ -1196,8 +1039,8 @@ function getApplicationContext(opts) {
     return { name: process.env.NX_TASK_TARGET_PROJECT };
   }
   try {
-    const packageJsonString = import_node_fs7.default.readFileSync(
-      import_node_path7.default.join(opts?.packageRoot || ".", "package.json"),
+    const packageJsonString = import_node_fs6.default.readFileSync(
+      import_node_path6.default.join(opts?.packageRoot || ".", "package.json"),
       "utf-8"
     );
     const packageJson = JSON.parse(packageJsonString);
@@ -1220,7 +1063,7 @@ function getApplicationContext(opts) {
 }
 
 // src/config/microfrontends/server/utils/get-output-file-path.ts
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/config/microfrontends/server/constants.ts
 var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
@@ -1228,7 +1071,7 @@ var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
 
 // src/config/microfrontends/server/utils/get-output-file-path.ts
 function getOutputFilePath() {
-  return import_node_path8.default.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+  return import_node_path7.default.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
 }
 
 // src/config/microfrontends/server/validation.ts
@@ -1241,16 +1084,6 @@ var schema_default = {
   $ref: "#/definitions/Config",
   definitions: {
     Config: {
-      anyOf: [
-        {
-          $ref: "#/definitions/MainConfig"
-        },
-        {
-          $ref: "#/definitions/ChildConfig"
-        }
-      ]
-    },
-    MainConfig: {
       type: "object",
       properties: {
         $schema: {
@@ -1507,27 +1340,6 @@ var schema_default = {
       },
       required: ["paths"],
       additionalProperties: false
-    },
-    ChildConfig: {
-      type: "object",
-      properties: {
-        $schema: {
-          type: "string"
-        },
-        version: {
-          type: "string",
-          const: "1"
-        },
-        options: {
-          $ref: "#/definitions/Options"
-        },
-        partOf: {
-          type: "string",
-          description: "Applications that only serve a subset of the microfrontend routes only need to reference the name of the primary application that owns the full microfrontends configuration."
-        }
-      },
-      required: ["partOf"],
-      additionalProperties: false
     }
   }
 };
@@ -1536,13 +1348,54 @@ var schema_default = {
 var SCHEMA = schema_default;
 
 // src/config/microfrontends/server/validation.ts
-function filterAjvErrors(errors) {
+var LIST_FORMATTER2 = new Intl.ListFormat("en", {
+  style: "long",
+  type: "disjunction"
+});
+function formatAjvErrors(errors) {
   if (!errors) {
     return [];
   }
-  return errors.filter((error) => {
-    return error.keyword === "additionalProperties" || error.keyword === "required";
-  });
+  const errorMessages = [];
+  for (const error of errors) {
+    if (error.instancePath === "" && (error.keyword === "anyOf" || error.keyword === "required" && error.params.missingProperty === "partOf")) {
+      continue;
+    }
+    const instancePath = error.instancePath.slice(1);
+    const formattedInstancePath = instancePath === "" ? "at the root" : `in field ${instancePath}`;
+    if (error.keyword === "required" && error.params.missingProperty === "routing" && instancePath.split("/").length === 2) {
+      errorMessages.push(
+        `Unable to infer if ${instancePath} is the default app or a child app. This usually means that there is another error in the configuration.`
+      );
+    } else if (error.keyword === "anyOf" && instancePath.split("/").length > 2) {
+      const anyOfErrors = errors.filter(
+        (e) => e.instancePath === error.instancePath && e.keyword !== "anyOf"
+      );
+      if (anyOfErrors.every((e) => e.keyword === "type")) {
+        const allowedTypes = LIST_FORMATTER2.format(
+          anyOfErrors.map((e) => {
+            return e.keyword === "type" ? String(e.params.type) : "unknown";
+          })
+        );
+        errorMessages.push(
+          `Incorrect type for ${instancePath}. Must be one of ${allowedTypes}`
+        );
+      } else {
+        errorMessages.push(
+          `Invalid field for ${instancePath}. Possible error messages are ${LIST_FORMATTER2.format(anyOfErrors.map((e) => e.message ?? ""))}`
+        );
+      }
+    } else if (error.keyword === "additionalProperties" && !(error.params.additionalProperty === "routing" && instancePath.split("/").length === 2)) {
+      errorMessages.push(
+        `Property '${error.params.additionalProperty}' is not allowed ${formattedInstancePath}`
+      );
+    } else if (error.keyword === "required") {
+      errorMessages.push(
+        `Property '${error.params.missingProperty}' is required ${formattedInstancePath}`
+      );
+    }
+  }
+  return errorMessages;
 }
 function validateSchema(configString) {
   const parsedConfig = (0, import_jsonc_parser3.parse)(configString);
@@ -1551,8 +1404,10 @@ function validateSchema(configString) {
   const isValid = validate(parsedConfig);
   if (!isValid) {
     throw new MicrofrontendError(
-      `Invalid microfrontends config:
- - ${ajv.errorsText(filterAjvErrors(validate.errors), { separator: "\n - " })}
+      `Invalid microfrontends config:${formatAjvErrors(validate.errors).map((error) => `
+ - ${error}`).join(
+        ""
+      )}
 
 See https://openapi.vercel.sh/microfrontends.json for the schema.`,
       { type: "config", subtype: "does_not_match_schema" }
@@ -1562,7 +1417,13 @@ See https://openapi.vercel.sh/microfrontends.json for the schema.`,
 }
 
 // src/config/microfrontends/server/index.ts
-var MicrofrontendsServer = class extends Microfrontends {
+var MicrofrontendsServer = class {
+  constructor({
+    config,
+    overrides
+  }) {
+    this.config = new MicrofrontendConfigIsomorphic({ config, overrides });
+  }
   /**
    * Writes the configuration to a file.
    */
@@ -1570,8 +1431,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    import_node_fs8.default.mkdirSync((0, import_node_path9.dirname)(outputPath), { recursive: true });
-    import_node_fs8.default.writeFileSync(
+    import_node_fs7.default.mkdirSync((0, import_node_path8.dirname)(outputPath), { recursive: true });
+    import_node_fs7.default.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -1586,22 +1447,19 @@ var MicrofrontendsServer = class extends Microfrontends {
    */
   static fromUnknown({
     config,
-    cookies,
-    meta
+    cookies
   }) {
     const overrides = cookies ? parseOverrides(cookies) : void 0;
     if (typeof config === "string") {
       return new MicrofrontendsServer({
         config: MicrofrontendsServer.validate(config),
-        overrides,
-        meta
+        overrides
       });
     }
     if (typeof config === "object") {
       return new MicrofrontendsServer({
         config,
-        overrides,
-        meta
+        overrides
       });
     }
     throw new MicrofrontendError(
@@ -1614,13 +1472,11 @@ var MicrofrontendsServer = class extends Microfrontends {
    * Uses additional validation that is only available when in a node runtime
    */
   static fromEnv({
-    cookies,
-    meta
+    cookies
   }) {
     return new MicrofrontendsServer({
       config: MicrofrontendsServer.validate(getConfigStringFromEnv()),
-      overrides: parseOverrides(cookies),
-      meta
+      overrides: parseOverrides(cookies)
     });
   }
   /**
@@ -1643,29 +1499,22 @@ var MicrofrontendsServer = class extends Microfrontends {
   static infer({
     directory,
     filePath,
-    meta,
-    cookies,
-    options
+    cookies
   } = {}) {
-    if (filePath && meta) {
+    if (filePath) {
       return MicrofrontendsServer.fromFile({
         filePath,
-        cookies,
-        meta,
-        options
+        cookies
       });
     }
     try {
       const packageRoot = findPackageRoot(directory);
       const { name: appName } = getApplicationContext({ packageRoot });
-      const configMeta = meta ?? { fromApp: appName };
       const maybeConfig = findConfig({ dir: packageRoot });
       if (maybeConfig) {
         return MicrofrontendsServer.fromFile({
           filePath: maybeConfig,
-          cookies,
-          meta: configMeta,
-          options
+          cookies
         });
       }
       const repositoryRoot = findRepositoryRoot();
@@ -1679,14 +1528,15 @@ var MicrofrontendsServer = class extends Microfrontends {
         if (maybeConfigFromDefault) {
           return MicrofrontendsServer.fromFile({
             filePath: maybeConfigFromDefault,
-            cookies,
-            meta: configMeta,
-            options
+            cookies
           });
         }
       }
       throw new Error("Unable to infer");
     } catch (e) {
+      if (e instanceof MicrofrontendError) {
+        throw e;
+      }
       throw new MicrofrontendError(
         "Unable to locate and parse microfrontends configuration",
         { cause: e, type: "config", subtype: "inference_failed" }
@@ -1698,44 +1548,14 @@ var MicrofrontendsServer = class extends Microfrontends {
    */
   static fromFile({
     filePath,
-    cookies,
-    meta,
-    options
+    cookies
   }) {
     try {
-      const configJson = import_node_fs8.default.readFileSync(filePath, "utf-8");
+      const configJson = import_node_fs7.default.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
-      if (!isMainConfig(config) && options?.resolveMainConfig) {
-        const repositoryRoot = findRepositoryRoot();
-        const isMonorepo2 = isMonorepo({ repositoryRoot });
-        if (isMonorepo2) {
-          const packagePath = findPackagePath({
-            repositoryRoot,
-            name: config.partOf
-          });
-          if (!packagePath) {
-            throw new MicrofrontendError(
-              `Could not find default application "${config.partOf}" in the repository`,
-              { type: "config", subtype: "not_found" }
-            );
-          }
-          const maybeConfig = findConfig({ dir: packagePath });
-          if (!maybeConfig) {
-            throw new MicrofrontendError(
-              `Could not find microfrontends configuration in ${packagePath}`,
-              { type: "config", subtype: "not_found" }
-            );
-          }
-          return MicrofrontendsServer.fromMainConfigFile({
-            filePath: maybeConfig,
-            overrides: cookies ? parseOverrides(cookies) : void 0
-          });
-        }
-      }
       return new MicrofrontendsServer({
         config,
-        overrides: cookies ? parseOverrides(cookies) : void 0,
-        meta
+        overrides: cookies ? parseOverrides(cookies) : void 0
       });
     } catch (e) {
       throw MicrofrontendError.handle(e, {
@@ -1744,24 +1564,15 @@ var MicrofrontendsServer = class extends Microfrontends {
     }
   }
   /*
-   * Generates a MicrofrontendMainConfig instance from a file.
+   * Generates a MicrofrontendsServer instance from a file.
    */
   static fromMainConfigFile({
     filePath,
     overrides
   }) {
     try {
-      const config = import_node_fs8.default.readFileSync(filePath, "utf-8");
+      const config = import_node_fs7.default.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
-      if (!isMainConfig(validatedConfig)) {
-        throw new MicrofrontendError(
-          `${filePath} is not a main microfrontend config`,
-          {
-            type: "config",
-            subtype: "invalid_main_path"
-          }
-        );
-      }
       const [defaultApplication] = Object.entries(validatedConfig.applications).filter(([, app]) => isDefaultApp(app)).map(([name]) => name);
       if (!defaultApplication) {
         throw new MicrofrontendError(
@@ -1771,8 +1582,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       }
       return new MicrofrontendsServer({
         config: validatedConfig,
-        overrides,
-        meta: { fromApp: defaultApplication }
+        overrides
       });
     } catch (e) {
       throw MicrofrontendError.handle(e, {
@@ -1800,8 +1610,8 @@ function mfePort(packageDir) {
   };
 }
 function getPackageJson(packageDir) {
-  const filePath = import_node_path10.default.join(packageDir, "package.json");
-  return JSON.parse(import_node_fs9.default.readFileSync(filePath, "utf-8"));
+  const filePath = import_node_path9.default.join(packageDir, "package.json");
+  return JSON.parse(import_node_fs8.default.readFileSync(filePath, "utf-8"));
 }
 function loadConfig({
   packageDir,
@@ -1810,9 +1620,7 @@ function loadConfig({
   let config;
   try {
     config = MicrofrontendsServer.infer({
-      directory: packageDir,
-      meta: { fromApp: appName },
-      options: { resolveMainConfig: true }
+      directory: packageDir
     });
   } catch (e) {
     return void 0;