@vercel/microfrontends 1.1.1-canary.3 → 1.1.1-canary.5

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.3",
+  version: "1.1.1-canary.5",
   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"
       ],
@@ -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,124 @@ 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"
@@ -387,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
             });
           }
@@ -434,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}`;
     }
@@ -819,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;
 
@@ -946,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",
         {
@@ -990,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() {
@@ -1042,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(
@@ -1060,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(
@@ -1068,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;
   }
   /**
@@ -1107,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
     });
@@ -1121,93 +1079,9 @@ 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);
@@ -1236,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 = [
@@ -1305,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,
@@ -1324,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) {
@@ -1347,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) {
@@ -1363,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) {
@@ -1398,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."
@@ -1416,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;
     }
   }
@@ -1429,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 };
@@ -1439,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);
@@ -1463,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";
@@ -1471,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
@@ -1484,16 +1302,6 @@ var schema_default = {
   $ref: "#/definitions/Config",
   definitions: {
     Config: {
-      anyOf: [
-        {
-          $ref: "#/definitions/MainConfig"
-        },
-        {
-          $ref: "#/definitions/ChildConfig"
-        }
-      ]
-    },
-    MainConfig: {
       type: "object",
       properties: {
         $schema: {
@@ -1750,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
     }
   }
 };
@@ -1848,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.
    */
@@ -1856,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(),
@@ -1872,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(
@@ -1900,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)
     });
   }
   /**
@@ -1929,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();
@@ -1965,9 +1746,7 @@ var MicrofrontendsServer = class extends Microfrontends {
         if (maybeConfigFromDefault) {
           return MicrofrontendsServer.fromFile({
             filePath: maybeConfigFromDefault,
-            cookies,
-            meta: configMeta,
-            options
+            cookies
           });
         }
       }
@@ -1987,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, {
@@ -2033,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(
@@ -2060,8 +1800,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       }
       return new MicrofrontendsServer({
         config: validatedConfig,
-        overrides,
-        meta: { fromApp: defaultApplication }
+        overrides
       });
     } catch (e) {
       throw MicrofrontendError.handle(e, {
@@ -2154,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;
   }
@@ -2342,15 +2076,33 @@ 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();
+    }
+    LocalProxy.validateLocalApps(localApps, microfrontends.config);
+    return new LocalProxy(microfrontends.config, { localApps, proxyPort });
+  }
+  static validateLocalApps(localApps, config) {
+    const unknownApps = [];
+    const allApps = /* @__PURE__ */ new Set();
+    for (const app of config.getAllApplications()) {
+      allApps.add(app.name);
+    }
+    for (const app of localApps) {
+      if (!allApps.has(app)) {
+        unknownApps.push(app);
+      }
+    }
+    if (unknownApps.length) {
+      throw new Error(
+        `The following apps passed via --local-apps are not in the microfrontends config: ${unknownApps.join(", ")} (microfrontends config contains: ${Array.from(allApps).join(", ")})`
+      );
     }
-    throw new Error(
-      `Unable to find main config from child application (${filePath})`
-    );
   }
   startServer() {
     const httpServer = http.createServer(
@@ -2485,8 +2237,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 });
@@ -2504,8 +2256,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,
@@ -2514,9 +2266,7 @@ function loadConfig({
   let config;
   try {
     config = MicrofrontendsServer.infer({
-      directory: packageDir,
-      meta: { fromApp: appName },
-      options: { resolveMainConfig: true }
+      directory: packageDir
     });
   } catch (e) {
     return void 0;
@@ -2543,7 +2293,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, --local-apps <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");
@@ -2551,7 +2301,7 @@ function main() {
     return parsedValue;
   }).action((filePath, options) => {
     const localProxy = LocalProxy.fromFile(filePath, {
-      localApps: options.names,
+      localApps: options.localApps,
       proxyPort: options.port
     });
     localProxy.startServer();