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

package/dist/bin/cli.cjs

@@ -29,7 +29,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "@vercel/microfrontends",
-  version: "1.1.1-canary.2",
+  version: "1.1.1-canary.4",
   private: false,
   description: "Defines configuration and utilities for microfrontends development",
   keywords: [
@@ -62,10 +62,6 @@ var package_default = {
       import: "./dist/experimental/vite.js",
       require: "./dist/experimental/vite.cjs"
     },
-    "./microfrontends": {
-      import: "./dist/microfrontends.js",
-      require: "./dist/microfrontends.cjs"
-    },
     "./overrides": {
       import: "./dist/overrides.js",
       require: "./dist/overrides.cjs"
@@ -125,9 +121,6 @@ var package_default = {
       "experimental/vite": [
         "./dist/experimental/vite.d.ts"
       ],
-      microfrontends: [
-        "./dist/microfrontends.d.ts"
-      ],
       overrides: [
         "./dist/overrides.d.ts"
       ],
@@ -216,7 +209,7 @@ var package_default = {
     tsup: "^6.6.2",
     tsx: "^4.6.2",
     typescript: "5.7.3",
-    vite: "^5.1.6",
+    vite: "5.4.11",
     webpack: "5"
   },
   peerDependencies: {
@@ -261,10 +254,8 @@ var import_cookie = require("cookie");
 var import_path_to_regexp3 = require("path-to-regexp");
 var import_http_proxy = __toESM(require("http-proxy"), 1);
 
-// src/config/schema/utils/is-default-app.ts
-function isDefaultApp(a) {
-  return !("routing" in a);
-}
+// src/config/microfrontends-config/isomorphic/index.ts
+var import_jsonc_parser = require("jsonc-parser");
 
 // src/config/errors.ts
 var MicrofrontendError = class extends Error {
@@ -358,8 +349,128 @@ var MicrofrontendError = class extends Error {
   }
 };
 
-// src/config/microfrontends-config/isomorphic/validation.ts
+// src/config/microfrontends-config/utils/get-config-from-env.ts
+function getConfigStringFromEnv() {
+  const config = process.env.MFE_CONFIG;
+  if (!config) {
+    throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
+      type: "config",
+      subtype: "not_found_in_env"
+    });
+  }
+  return config;
+}
+
+// src/config/schema/utils/is-default-app.ts
+function isDefaultApp(a) {
+  return !("routing" in a);
+}
+
+// src/config/microfrontends-config/client/index.ts
 var import_path_to_regexp = require("path-to-regexp");
+var MicrofrontendConfigClient = class {
+  constructor(config, opts) {
+    this.pathCache = {};
+    this.serialized = config;
+    if (opts?.removeFlaggedPaths) {
+      for (const app of Object.values(config.applications)) {
+        if (app.routing) {
+          app.routing = app.routing.filter((match) => !match.flag);
+        }
+      }
+    }
+    this.applications = config.applications;
+  }
+  /**
+   * Create a new `MicrofrontendConfigClient` from a JSON string.
+   * Config must be passed in to remain framework agnostic
+   */
+  static fromEnv(config, opts) {
+    if (!config) {
+      throw new Error("No microfrontends configuration found");
+    }
+    return new MicrofrontendConfigClient(
+      JSON.parse(config),
+      opts
+    );
+  }
+  isEqual(other) {
+    return JSON.stringify(this.applications) === JSON.stringify(other.applications);
+  }
+  getApplicationNameForPath(path7) {
+    if (!path7.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path7]) {
+      return this.pathCache[path7];
+    }
+    const pathname = new URL(path7, "https://example.com").pathname;
+    for (const [name, application] of Object.entries(this.applications)) {
+      if (application.routing) {
+        for (const group of application.routing) {
+          for (const childPath of group.paths) {
+            const regexp = (0, import_path_to_regexp.pathToRegexp)(childPath);
+            if (regexp.test(pathname)) {
+              this.pathCache[path7] = name;
+              return name;
+            }
+          }
+        }
+      }
+    }
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path7] = defaultApplication[0];
+    return defaultApplication[0];
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
+
+// src/config/overrides/is-override-cookie.ts
+function isOverrideCookie(cookie) {
+  return Boolean(cookie.name?.startsWith(OVERRIDES_COOKIE_PREFIX));
+}
+
+// src/config/overrides/get-override-from-cookie.ts
+function getOverrideFromCookie(cookie) {
+  if (!isOverrideCookie(cookie) || !cookie.value)
+    return;
+  return {
+    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
+    host: cookie.value
+  };
+}
+
+// src/config/overrides/parse-overrides.ts
+function parseOverrides(cookies) {
+  const overridesConfig = { applications: {} };
+  cookies.forEach((cookie) => {
+    const override = getOverrideFromCookie(cookie);
+    if (!override)
+      return;
+    overridesConfig.applications[override.application] = {
+      environment: { host: override.host }
+    };
+  });
+  return overridesConfig;
+}
+
+// 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;
@@ -383,7 +494,7 @@ var validateConfigPaths = (applicationConfigsById) => {
           } else {
             pathsByApplicationId.set(path7, {
               applications: [id],
-              matcher: (0, import_path_to_regexp.pathToRegexp)(path7),
+              matcher: (0, import_path_to_regexp2.pathToRegexp)(path7),
               applicationId: id
             });
           }
@@ -430,7 +541,7 @@ var validateConfigPaths = (applicationConfigsById) => {
 var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
 function validatePathExpression(path7) {
   try {
-    const tokens = (0, import_path_to_regexp.parse)(path7);
+    const tokens = (0, import_path_to_regexp2.parse)(path7);
     if (/(?<!\\)\{/.test(path7)) {
       return `Optional paths are not supported: ${path7}`;
     }
@@ -492,15 +603,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.",
@@ -508,8 +619,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" }
     );
   }
@@ -812,125 +926,6 @@ var ChildApplication = class extends Application {
   }
 };
 
-// src/config/microfrontends-config/isomorphic/index.ts
-var import_jsonc_parser = require("jsonc-parser");
-
-// src/config/microfrontends-config/utils/get-config-from-env.ts
-function getConfigStringFromEnv() {
-  const config = process.env.MFE_CONFIG;
-  if (!config) {
-    throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
-      type: "config",
-      subtype: "not_found_in_env"
-    });
-  }
-  return config;
-}
-
-// src/config/schema/utils/is-main-config.ts
-function isMainConfig(c) {
-  return !("partOf" in c);
-}
-
-// src/config/microfrontends-config/client/index.ts
-var import_path_to_regexp2 = require("path-to-regexp");
-var MicrofrontendConfigClient = class {
-  constructor(config, opts) {
-    this.pathCache = {};
-    this.serialized = config;
-    if (opts?.removeFlaggedPaths) {
-      for (const app of Object.values(config.applications)) {
-        if (app.routing) {
-          app.routing = app.routing.filter((match) => !match.flag);
-        }
-      }
-    }
-    this.applications = config.applications;
-  }
-  /**
-   * Create a new `MicrofrontendConfigClient` from a JSON string.
-   * Config must be passed in to remain framework agnostic
-   */
-  static fromEnv(config, opts) {
-    if (!config) {
-      throw new Error("No microfrontends configuration found");
-    }
-    return new MicrofrontendConfigClient(
-      JSON.parse(config),
-      opts
-    );
-  }
-  isEqual(other) {
-    return JSON.stringify(this.applications) === JSON.stringify(other.applications);
-  }
-  getApplicationNameForPath(path7) {
-    if (!path7.startsWith("/")) {
-      throw new Error(`Path must start with a /`);
-    }
-    if (this.pathCache[path7]) {
-      return this.pathCache[path7];
-    }
-    const pathname = new URL(path7, "https://example.com").pathname;
-    for (const [name, application] of Object.entries(this.applications)) {
-      if (application.routing) {
-        for (const group of application.routing) {
-          for (const childPath of group.paths) {
-            const regexp = (0, import_path_to_regexp2.pathToRegexp)(childPath);
-            if (regexp.test(pathname)) {
-              this.pathCache[path7] = name;
-              return name;
-            }
-          }
-        }
-      }
-    }
-    const defaultApplication = Object.entries(this.applications).find(
-      ([, application]) => application.default
-    );
-    if (!defaultApplication) {
-      return null;
-    }
-    this.pathCache[path7] = defaultApplication[0];
-    return defaultApplication[0];
-  }
-  serialize() {
-    return this.serialized;
-  }
-};
-
-// src/config/overrides/constants.ts
-var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
-var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
-
-// src/config/overrides/is-override-cookie.ts
-function isOverrideCookie(cookie) {
-  return Boolean(cookie.name?.startsWith(OVERRIDES_COOKIE_PREFIX));
-}
-
-// src/config/overrides/get-override-from-cookie.ts
-function getOverrideFromCookie(cookie) {
-  if (!isOverrideCookie(cookie) || !cookie.value)
-    return;
-  return {
-    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
-    host: cookie.value
-  };
-}
-
-// src/config/overrides/parse-overrides.ts
-function parseOverrides(cookies) {
-  const overridesConfig = { applications: {} };
-  cookies.forEach((cookie) => {
-    const override = getOverrideFromCookie(cookie);
-    if (!override)
-      return;
-    overridesConfig.applications[override.application] = {
-      environment: { host: override.host }
-    };
-  });
-  return overridesConfig;
-}
-
 // src/config/microfrontends-config/isomorphic/constants.ts
 var DEFAULT_LOCAL_PROXY_PORT = 3024;
 
@@ -939,42 +934,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",
         {
@@ -983,34 +964,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);
-      }
+    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
+      overrides: parseOverrides(cookies ?? [])
     });
   }
   isOverridesDisabled() {
@@ -1035,7 +1012,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(
@@ -1053,7 +1030,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(
@@ -1061,19 +1038,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;
   }
   /**
@@ -1100,11 +1067,9 @@ var MicrofrontendConfigIsomorphic = class {
         }
       ])
     );
-    if (this.defaultApplication) {
-      applications[this.defaultApplication.name] = {
-        default: true
-      };
-    }
+    applications[this.defaultApplication.name] = {
+      default: true
+    };
     return new MicrofrontendConfigClient({
       applications
     });
@@ -1114,106 +1079,28 @@ var MicrofrontendConfigIsomorphic = class {
   }
 };
 
-// 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/utils/is-main-config.ts
-function isMainConfig2(c) {
-  return !("partOf" in c);
-}
-
 // src/config/microfrontends/server/index.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path9 = require("path");
-
-// 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/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());
-  }
-};
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path8 = require("path");
 
 // 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) {
-    const gitPath = import_node_path.default.join(currentDir, GIT_DIRECTORY);
-    if (import_node_fs.default.existsSync(gitPath) && import_node_fs.default.statSync(gitPath).isDirectory()) {
+    if (hasGitDirectory(currentDir) || hasPnpmWorkspaces(currentDir)) {
       return currentDir;
     }
     currentDir = import_node_path.default.dirname(currentDir);
@@ -1223,67 +1110,11 @@ function findRepositoryRoot(startDir) {
   );
 }
 
-// src/config/microfrontends/utils/find-package-path.ts
+// src/config/microfrontends/utils/find-default-package.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);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
 
 // src/config/constants.ts
 var CONFIGURATION_FILENAMES = [
@@ -1292,13 +1123,13 @@ var CONFIGURATION_FILENAMES = [
 ];
 
 // src/config/microfrontends/utils/find-default-package.ts
-var configCache2 = {};
+var configCache = {};
 function findDefaultMicrofrontendsPackages({
   repositoryRoot,
   applicationName
 }) {
   try {
-    const microfrontendsJsonPaths = import_fast_glob2.default.globSync(
+    const microfrontendsJsonPaths = import_fast_glob.default.globSync(
       `**/{${CONFIGURATION_FILENAMES.join(",")}}`,
       {
         cwd: repositoryRoot,
@@ -1311,12 +1142,12 @@ function findDefaultMicrofrontendsPackages({
     const matchingPaths = [];
     for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
       try {
-        const microfrontendsJsonContent = (0, import_node_fs3.readFileSync)(
+        const microfrontendsJsonContent = (0, import_node_fs2.readFileSync)(
           microfrontendsJsonPath,
           "utf-8"
         );
         const microfrontendsJson = (0, import_jsonc_parser2.parse)(microfrontendsJsonContent);
-        if (isMainConfig(microfrontendsJson) && microfrontendsJson.applications[applicationName]) {
+        if (microfrontendsJson.applications[applicationName]) {
           matchingPaths.push(microfrontendsJsonPath);
         }
       } catch (error) {
@@ -1324,7 +1155,7 @@ function findDefaultMicrofrontendsPackages({
     }
     if (matchingPaths.length > 1) {
       throw new Error(
-        `Found multiple default applications referencing "${applicationName}" in the repository, this is not yet supported.
+        `Found multiple default applications referencing "${applicationName}" in the repository, but only one is allowed.
 ${matchingPaths.join("\n  \u2022 ")}`
       );
     }
@@ -1334,15 +1165,15 @@ ${matchingPaths.join("\n  \u2022 ")}`
       );
     }
     const [packageJsonPath] = matchingPaths;
-    return (0, import_node_path3.dirname)(packageJsonPath);
+    return (0, import_node_path2.dirname)(packageJsonPath);
   } catch (error) {
     return null;
   }
 }
 function findDefaultMicrofrontendsPackage(opts) {
   const cacheKey = `${opts.repositoryRoot}-${opts.applicationName}`;
-  if (configCache2[cacheKey]) {
-    return configCache2[cacheKey];
+  if (configCache[cacheKey]) {
+    return configCache[cacheKey];
   }
   const result = findDefaultMicrofrontendsPackages(opts);
   if (!result) {
@@ -1350,32 +1181,32 @@ function findDefaultMicrofrontendsPackage(opts) {
       "Error trying to resolve the main microfrontends configuration"
     );
   }
-  configCache2[cacheKey] = result;
+  configCache[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);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 function isMonorepo({
   repositoryRoot
 }) {
   try {
-    if (import_node_fs4.default.existsSync(import_node_path4.default.join(repositoryRoot, "pnpm-workspace.yaml"))) {
+    if (import_node_fs3.default.existsSync(import_node_path3.default.join(repositoryRoot, "pnpm-workspace.yaml"))) {
       return true;
     }
-    if (import_node_fs4.default.existsSync(import_node_path4.default.join(repositoryRoot, "vlt-workspaces.json"))) {
+    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_path4.default.resolve(repositoryRoot)) {
+    if (process.env.NX_WORKSPACE_ROOT === import_node_path3.default.resolve(repositoryRoot)) {
       return true;
     }
-    const packageJsonPath = import_node_path4.default.join(repositoryRoot, "package.json");
-    if (!import_node_fs4.default.existsSync(packageJsonPath)) {
+    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_fs4.default.readFileSync(packageJsonPath, "utf-8")
+      import_node_fs3.default.readFileSync(packageJsonPath, "utf-8")
     );
     return packageJson.workspaces !== void 0;
   } catch (error) {
@@ -1385,17 +1216,17 @@ function isMonorepo({
 }
 
 // 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 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_path5.default.parse(currentDir).root) {
-    const pkgJsonPath = import_node_path5.default.join(currentDir, PACKAGE_JSON);
-    if (import_node_fs5.default.existsSync(pkgJsonPath)) {
+  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_path5.default.dirname(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."
@@ -1403,12 +1234,12 @@ function findPackageRoot(startDir) {
 }
 
 // src/config/microfrontends/utils/find-config.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path6 = require("path");
+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_path6.join)(dir, filename);
-    if (import_node_fs6.default.existsSync(maybeConfig)) {
+    const maybeConfig = (0, import_node_path5.join)(dir, filename);
+    if (import_node_fs5.default.existsSync(maybeConfig)) {
       return maybeConfig;
     }
   }
@@ -1416,8 +1247,8 @@ function findConfig({ dir }) {
 }
 
 // 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 };
@@ -1426,8 +1257,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);
@@ -1450,7 +1281,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";
@@ -1458,7 +1289,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
@@ -1471,16 +1302,6 @@ var schema_default = {
   $ref: "#/definitions/Config",
   definitions: {
     Config: {
-      anyOf: [
-        {
-          $ref: "#/definitions/MainConfig"
-        },
-        {
-          $ref: "#/definitions/ChildConfig"
-        }
-      ]
-    },
-    MainConfig: {
       type: "object",
       properties: {
         $schema: {
@@ -1737,27 +1558,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
     }
   }
 };
@@ -1766,13 +1566,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);
@@ -1781,8 +1622,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" }
@@ -1792,7 +1635,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.
    */
@@ -1800,8 +1649,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(),
@@ -1816,22 +1665,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(
@@ -1844,13 +1690,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)
     });
   }
   /**
@@ -1873,29 +1717,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();
@@ -1909,14 +1746,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" }
@@ -1928,44 +1766,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, {
@@ -1974,24 +1782,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(
@@ -2001,8 +1800,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       }
       return new MicrofrontendsServer({
         config: validatedConfig,
-        overrides,
-        meta: { fromApp: defaultApplication }
+        overrides
       });
     } catch (e) {
       throw MicrofrontendError.handle(e, {
@@ -2095,14 +1893,9 @@ var ProxyRequestRouter = class {
       Object.entries(cookies).map(([name, value]) => ({ name, value }))
     );
     const hasOverrides = Object.keys(cookieOverrides.applications).length > 0;
-    const fromApp = this.config.getDefaultApplication().name;
     const serialized = this.config.serialize().config;
-    if (!isMainConfig(serialized)) {
-      throw new Error("unreachable");
-    }
-    return hasOverrides ? new MicrofrontendMainConfig({
+    return hasOverrides ? new MicrofrontendConfigIsomorphic({
       config: serialized,
-      meta: { fromApp },
       overrides: cookieOverrides
     }) : this.config;
   }
@@ -2283,15 +2076,15 @@ var LocalProxy = class {
     localApps,
     proxyPort
   }) {
-    const microfrontends = MicrofrontendsServer.infer({
-      directory: filePath
-    });
-    if (isMainConfig2(microfrontends.config)) {
-      return new LocalProxy(microfrontends.config, { localApps, proxyPort });
+    let microfrontends;
+    if (filePath) {
+      microfrontends = MicrofrontendsServer.fromFile({
+        filePath
+      });
+    } else {
+      microfrontends = MicrofrontendsServer.infer();
     }
-    throw new Error(
-      `Unable to find main config from child application (${filePath})`
-    );
+    return new LocalProxy(microfrontends.config, { localApps, proxyPort });
   }
   startServer() {
     const httpServer = http.createServer(
@@ -2426,8 +2219,8 @@ function removeMfeFlagQuery(req) {
 var import_node_process = require("process");
 
 // src/utils/mfe-port.ts
-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);
 function mfePort(packageDir) {
   const { name: appName, version } = getPackageJson(packageDir);
   const result = loadConfig({ packageDir, appName });
@@ -2445,8 +2238,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,
@@ -2455,9 +2248,7 @@ function loadConfig({
   let config;
   try {
     config = MicrofrontendsServer.infer({
-      directory: packageDir,
-      meta: { fromApp: appName },
-      options: { resolveMainConfig: true }
+      directory: packageDir
     });
   } catch (e) {
     return void 0;
@@ -2484,7 +2275,7 @@ function header({ name, version, port }) {
 function main() {
   const program = new import_commander.Command();
   program.name(package_default.name).description("Tools for working with micro-frontend applications").version(package_default.version, "-v, --version", "output the current version");
-  program.command("proxy").argument("<filePath>", "Path to the micro-frontend configuration file").option("--names <names...>", "List of locally running applications", []).option("--port <port>", "Port proxy will use", (value) => {
+  program.command("proxy").argument("[filePath]", "Path to the micro-frontend configuration file").option("--names <names...>", "List of locally running applications", []).option("--port <port>", "Port proxy will use", (value) => {
     const parsedValue = Number.parseInt(value, 10);
     if (isNaN(parsedValue) || parsedValue <= 0) {
       throw new Error("Port must be a positive number");