@vercel/microfrontends 0.14.0 → 0.16.0

package/dist/next/config.js

@@ -1,31 +1,42 @@
 // src/next/config/index.ts
-import fs3 from "node:fs";
+import fs6 from "node:fs";
 
-// src/config/microfrontend-config.ts
-import fs2 from "node:fs";
+// src/config/microfrontends/server/index.ts
+import fs5 from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
 
-// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
-import path from "node:path";
+// src/config/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
 
-// src/config-v2/microfrontends/server/constants.ts
-var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
-var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
+// src/config/overrides/is-override-cookie.ts
+function isOverrideCookie(cookie) {
+  var _a;
+  return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+}
 
-// src/utils/is-vercel.ts
-function isVercel() {
-  return process.env.VERCEL === "1";
+// 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-v2/microfrontends/server/utils/get-output-file-path.ts
-function getOutputFilePath() {
-  if (isVercel()) {
-    return path.join(
-      ".vercel",
-      MFE_CONFIG_DEFAULT_FILE_PATH,
-      MFE_CONFIG_DEFAULT_FILE_NAME
-    );
-  }
-  return path.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+// 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/errors.ts
@@ -120,131 +131,289 @@ var MicrofrontendError = class extends Error {
   }
 };
 
-// src/routing/url.ts
-function buildUrlSafeString(givenOpts = {}) {
-  const options = {
-    joinString: "-",
-    lowercaseOnly: true,
-    maxLen: 100,
-    regexRemovePattern: /(?:(?!(?:[a-z0-9])).)/gi,
-    trimWhitespace: true,
-    ...givenOpts
-  };
-  return {
-    generate: (...args) => {
-      const reJoinString = new RegExp(`${options.joinString}+`, "g");
-      let tag;
-      if (args.length === 0) {
-        throw new Error("generate method must be passed at least one argument");
+// 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/microfrontends-config/isomorphic/index.ts
+import { parse } from "jsonc-parser";
+
+// src/config/schema/utils/is-main-config.ts
+function isMainConfig(c) {
+  return !("partOf" in c);
+}
+
+// src/config/schema/utils/is-default-app.ts
+function isDefaultApp(a) {
+  return !("routing" in a);
+}
+
+// src/config/microfrontends-config/client/index.ts
+import { pathToRegexp } from "path-to-regexp";
+var MicrofrontendConfigClient = class {
+  constructor(config, opts) {
+    this.pathCache = {};
+    this.serialized = config;
+    if (opts == null ? void 0 : opts.removeFlaggedPaths) {
+      for (const app of Object.values(config.applications)) {
+        if (app.routing) {
+          app.routing = app.routing.filter((match) => !match.flag);
+        }
       }
-      for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (typeof arg !== "string")
-          throw new Error("all supplied arguments must be Strings");
-        if (options.trimWhitespace) {
-          args[i] = arg.trim();
+    }
+    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(path5) {
+    if (!path5.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path5]) {
+      return this.pathCache[path5];
+    }
+    const pathname = new URL(path5, "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 = pathToRegexp(childPath);
+            if (regexp.test(pathname)) {
+              this.pathCache[path5] = name;
+              return name;
+            }
+          }
         }
       }
-      tag = args.join(options.joinString);
-      tag = tag.replace(/\s/g, options.joinString);
-      if (options.lowercaseOnly)
-        tag = tag.toLowerCase();
-      tag = tag.replace(options.regexRemovePattern, (match) => {
-        if (match === options.joinString)
-          return match;
-        return "";
-      });
-      if (tag.length > options.maxLen)
-        tag = tag.substring(0, options.maxLen);
-      tag = tag.replace(reJoinString, options.joinString);
-      return tag;
     }
-  };
-}
-var urlSafeString = buildUrlSafeString().generate;
-function makeUrlSafe(name) {
-  return urlSafeString(name.replace(/\//g, "-")).replace(/^-*/g, "").replace(/-*$/g, "");
-}
-
-// src/config/overrides/config.ts
-var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
-var _Overrides = class {
-  constructor(config) {
-    this.config = config;
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path5] = defaultApplication[0];
+    return defaultApplication[0];
   }
-  static getAppEnvOverrideCookieName(zone) {
-    return `${_Overrides.overrideEnvCookiePrefix}${zone}`;
+  serialize() {
+    return this.serialized;
   }
-  static isOverrideCookie(cookie) {
-    var _a;
-    return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+};
+
+// src/config/microfrontends-config/isomorphic/validation.ts
+import { pathToRegexp as pathToRegexp2, parse as parsePathRegexp } from "path-to-regexp";
+var SUPPORTED_VERSIONS = ["2"];
+var validateConfigVersion = (version) => {
+  if (!SUPPORTED_VERSIONS.includes(version)) {
+    throw new MicrofrontendError(
+      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
+        ", "
+      )}`,
+      { type: "config", subtype: "unsupported_version" }
+    );
   }
-  static getOverrideFromCookie(cookie) {
-    if (!_Overrides.isOverrideCookie(cookie) || !cookie.value)
-      return;
-    return {
-      zone: cookie.name.replace(_Overrides.overrideEnvCookiePrefix, ""),
-      host: cookie.value
-    };
+};
+var validateConfigPaths = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
   }
-  static parseOverrides(cookies) {
-    const overridesConfig = { applications: {} };
-    cookies.forEach((cookie) => {
-      const override = _Overrides.getOverrideFromCookie(cookie);
-      if (!override)
-        return;
-      overridesConfig.applications[override.zone] = {
-        environment: { host: override.host }
-      };
+  const pathsByApplicationId = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const [id, app] of Object.entries(applicationConfigsById)) {
+    if (isDefaultApp(app)) {
+      continue;
+    }
+    for (const pathMatch of app.routing) {
+      for (const path5 of pathMatch.paths) {
+        const maybeError = validatePathExpression(path5);
+        if (maybeError) {
+          errors.push(maybeError);
+        }
+        const existing = pathsByApplicationId.get(path5);
+        if (existing) {
+          existing.applications.push(id);
+        } else {
+          pathsByApplicationId.set(path5, {
+            applications: [id],
+            matcher: pathToRegexp2(path5),
+            applicationId: id
+          });
+        }
+      }
+    }
+  }
+  const entries = Array.from(pathsByApplicationId.entries());
+  entries.forEach(([path5, { applications: ids, matcher, applicationId }]) => {
+    if (ids.length > 1) {
+      errors.push(
+        `Duplicate path "${path5}" for applications "${ids.join(", ")}"`
+      );
+    }
+    entries.forEach(
+      ([
+        matchPath,
+        { applications: matchIds, applicationId: matchApplicationId }
+      ]) => {
+        if (path5 === matchPath) {
+          return;
+        }
+        if (applicationId === matchApplicationId) {
+          return;
+        }
+        if (matcher.test(matchPath)) {
+          const source = `"${path5}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const destination = `"${matchPath}" of application${matchIds.length > 0 ? "s" : ""} ${matchIds.join(", ")}`;
+          errors.push(
+            `Overlapping path detected between ${source} and ${destination}`
+          );
+        }
+      }
+    );
+  });
+  if (errors.length) {
+    throw new MicrofrontendError(`Invalid paths: ${errors.join(", ")}`, {
+      type: "config",
+      subtype: "conflicting_paths"
     });
-    return overridesConfig;
   }
-  static validOverrideDomainsForZone(microfrontendConfig, zone) {
-    var _a, _b, _c, _d, _e;
-    const projectName = (_a = microfrontendConfig.getZone(zone).vercel) == null ? void 0 : _a.projectName;
-    if (!projectName) {
-      return [microfrontendConfig.getZone(zone).production.host];
+};
+var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
+function validatePathExpression(path5) {
+  const tokens = parsePathRegexp(path5);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === void 0) {
+      return `token ${i} in ${path5} is undefined, this shouldn't happen`;
+    }
+    if (typeof token !== "string") {
+      if (token.pattern !== PATH_DEFAULT_PATTERN) {
+        return `Path ${path5} cannot use a regular expression wildcard`;
+      }
+      if (token.prefix !== "/") {
+        return `Wildcard :${token.name} must be immediately after a / in ${path5}`;
+      }
+      if (token.suffix) {
+        return `Wildcard suffix on :${token.name} is not allowed. Suffixes are not supported`;
+      }
+      if (token.modifier && i !== tokens.length - 1) {
+        return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path5}. Modifiers are only allowed in the last path component`;
+      }
     }
-    const parsedProjectName = makeUrlSafe(projectName);
-    const previewDeploymentSuffix = (_c = (_b = microfrontendConfig.options) == null ? void 0 : _b.vercel) == null ? void 0 : _c.previewDeploymentSuffix;
-    const teamSlug = (_e = (_d = microfrontendConfig.options) == null ? void 0 : _d.vercel) == null ? void 0 : _e.teamSlug;
-    if (!teamSlug && !previewDeploymentSuffix) {
-      return [microfrontendConfig.getZone(zone).production.host];
+  }
+  return void 0;
+}
+var validateAppPaths = (name, app) => {
+  for (const group of app.routing) {
+    for (const p of group.paths) {
+      if (p === "/") {
+        continue;
+      }
+      if (p.endsWith("/")) {
+        throw new MicrofrontendError(
+          `Invalid path for application "${name}". ${p} must not end with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
+      if (!p.startsWith("/")) {
+        throw new MicrofrontendError(
+          `Invalid path for application "${name}". ${p} must start with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
     }
-    const suffix = previewDeploymentSuffix ? `.${previewDeploymentSuffix}` : `-${teamSlug}.vercel.app`;
-    return [
-      `${parsedProjectName}-git-([a-zA-Z0-9-]+)${suffix}`,
-      microfrontendConfig.getZone(zone).production.host
-    ];
   }
-  static validateOverrideDomain(microfrontendConfig, zone, domain) {
-    return new RegExp(
-      `^${_Overrides.validOverrideDomainsForZone(microfrontendConfig, zone).join(
-        "|"
-      )}$`
-    ).test(domain);
+};
+var validateConfigDefaultApplication = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
   }
-  serialize() {
-    return this.config;
+  const applicationsWithRouting = Object.entries(applicationConfigsById).filter(
+    ([, app]) => !isDefaultApp(app)
+  );
+  const applicationsWithRoutingNames = applicationsWithRouting.map(
+    ([key]) => key
+  );
+  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.`,
+      { type: "config", subtype: "no_default_application" }
+    );
+  }
+  if (numApplicationsWithoutRouting > 1) {
+    throw new MicrofrontendError(
+      `Only one application can omit "routing". Found ${applicationsWithRoutingNames.length - Object.keys(applicationConfigsById).length > 1}.`,
+      { type: "config", subtype: "multiple_default_applications" }
+    );
   }
 };
-var Overrides = _Overrides;
-Overrides.overrideEnvCookiePrefix = `${OVERRIDES_COOKIE_PREFIX}:env:`;
 
-// src/config/common/host.ts
+// src/config/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
+var PREFIX = "vc-ap";
+function generateAssetPrefixFromName({
+  name
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate an asset prefix");
+  }
+  return `${PREFIX}-${name}`;
+}
+
+// src/config/microfrontends-config/isomorphic/utils/generate-port.ts
+function generatePortFromName({
+  name,
+  minPort = 3e3,
+  maxPort = 8e3
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate a port");
+  }
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = (hash << 5) - hash + name.charCodeAt(i);
+    hash |= 0;
+  }
+  hash = Math.abs(hash);
+  const range = maxPort - minPort;
+  const port = minPort + hash % range;
+  return port;
+}
+
+// src/config/microfrontends-config/isomorphic/host.ts
 var Host = class {
-  constructor({ protocol, host, port }) {
-    this.protocol = protocol || "https";
+  constructor(hostConfig, options) {
+    const { protocol = "https", host, port } = hostConfig;
+    this.protocol = protocol;
     this.host = host;
     this.port = Host.getPort({ port, protocol: this.protocol });
-    this.serialized = {
-      protocol,
-      host,
-      ...port ? { port } : void 0
-    };
+    this.local = options == null ? void 0 : options.isLocal;
   }
   isLocal() {
-    return this.host === "localhost" || this.host === "127.0.0.1";
+    return this.local || this.host === "localhost" || this.host === "127.0.0.1";
   }
   static getPort({
     protocol,
@@ -270,176 +439,234 @@ var Host = class {
     const url = `${this.protocol}://${this.host}${this.isDefaultPort() && !includeDefaultPort ? "" : `:${this.port}`}`;
     return new URL(url);
   }
-  serialize() {
-    return this.serialized;
+};
+var LocalHost = class extends Host {
+  constructor({
+    appName,
+    ...hostConfig
+  }) {
+    const host = hostConfig.host ?? "localhost";
+    const port = hostConfig.port ?? generatePortFromName({ name: appName });
+    const protocol = hostConfig.protocol ?? "http";
+    super({ protocol, host, port });
   }
 };
 
-// src/config/common/application.ts
+// src/config/microfrontends-config/isomorphic/application.ts
 var Application = class {
   constructor(name, {
     app,
-    overrides
+    overrides,
+    isDefault
   }) {
-    Application.validate(name, app);
+    var _a, _b;
     this.name = name;
-    this.default = app.default;
-    this.routing = app.routing;
     this.development = {
-      local: new Host(app.development.local),
-      fallback: app.development.fallback ? new Host(app.development.fallback) : void 0
+      local: new LocalHost({
+        appName: name,
+        ...(_a = app.development) == null ? void 0 : _a.local
+      }),
+      fallback: ((_b = app.development) == null ? void 0 : _b.fallback) ? new Host(app.development.fallback) : void 0
     };
-    this.production = new Host(app.production);
+    this.production = app.production ? new Host(app.production) : void 0;
     this.vercel = app.vercel;
     this.overrides = (overrides == null ? void 0 : overrides.environment) ? {
       environment: new Host(overrides.environment)
     } : void 0;
+    this.default = isDefault ?? false;
+    this.serialized = app;
   }
   isDefault() {
     return this.default;
   }
-  static validate(name, app) {
-    var _a, _b, _c, _d, _e;
-    if (((_b = (_a = app.routing) == null ? void 0 : _a.assetPrefix) == null ? void 0 : _b.startsWith("/")) || ((_d = (_c = app.routing) == null ? void 0 : _c.assetPrefix) == null ? void 0 : _d.endsWith("/"))) {
-      throw new MicrofrontendError(
-        `Invalid assetPrefix for application "${name}". Must not start or end with a slash.`,
-        { type: "zone", subtype: "invalid_asset_prefix" }
-      );
-    }
-    for (const group of ((_e = app.routing) == null ? void 0 : _e.matches) ?? []) {
-      for (const p of group.paths) {
-        if (p === "/") {
-          continue;
-        }
-        if (p.endsWith("/")) {
-          throw new MicrofrontendError(
-            `Invalid path for application "${name}". ${p} must not end with a slash.`,
-            { type: "zone", subtype: "invalid_path" }
-          );
-        }
-        if (!p.startsWith("/")) {
-          throw new MicrofrontendError(
-            `Invalid path for application "${name}". ${p} must start with a slash.`,
-            { type: "zone", subtype: "invalid_path" }
-          );
-        }
-      }
-    }
+  getAssetPrefix() {
+    return generateAssetPrefixFromName({ name: this.name });
   }
   serialize() {
-    var _a, _b;
-    if (this.routing === void 0 || this.default) {
-      return {
-        default: true,
-        development: {
-          local: this.development.local.serialize(),
-          fallback: (_a = this.development.fallback) == null ? void 0 : _a.serialize()
-        },
-        production: this.production.serialize(),
-        vercel: this.vercel
-      };
-    }
-    return {
-      default: false,
-      routing: this.routing,
-      development: {
-        local: this.development.local.serialize(),
-        fallback: (_b = this.development.fallback) == null ? void 0 : _b.serialize()
-      },
-      production: this.production.serialize(),
-      vercel: this.vercel
-    };
+    return this.serialized;
+  }
+};
+var DefaultApplication = class extends Application {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    super(name, {
+      app,
+      overrides,
+      isDefault: true
+    });
+    this.default = true;
+    this.production = new Host(app.production);
+  }
+  getAssetPrefix() {
+    return "";
+  }
+};
+var ChildApplication = class extends Application {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    ChildApplication.validate(name, app);
+    super(name, {
+      app,
+      overrides,
+      isDefault: false
+    });
+    this.default = false;
+    this.routing = app.routing;
+  }
+  static validate(name, app) {
+    validateAppPaths(name, app);
   }
 };
 
-// src/config/common/microfrontend-config.ts
-var SUPPORTED_VERSIONS = ["1"];
+// src/config/microfrontends-config/isomorphic/constants.ts
 var DEFAULT_LOCAL_PROXY_PORT = 3024;
-var MicrofrontendConfigCommon = class {
+
+// src/config/microfrontends-config/isomorphic/index.ts
+var MicrofrontendConfigIsomorphic = class {
   constructor({
     config,
-    overrides
+    overrides,
+    meta
   }) {
-    this.zones = {};
-    var _a, _b, _c;
-    if (!SUPPORTED_VERSIONS.includes(config.version)) {
-      throw new MicrofrontendError(
-        `Unsupported version: ${config.version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
-          ", "
-        )}`,
-        { type: "config", subtype: "unsupported_version" }
+    this.childApplications = {};
+    var _a, _b, _c, _d;
+    MicrofrontendConfigIsomorphic.validate(config);
+    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.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 ? (_c = this.overrides) == null ? void 0 : _c.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 ? (_d = this.overrides) == null ? void 0 : _d.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: [] },
+          overrides: appOverrides
+        }
       );
     }
-    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
-    this.overrides = overrides && !disableOverrides ? new Overrides(overrides) : void 0;
-    for (const [zoneName, zoneConfig] of Object.entries(config.applications)) {
-      this.zones[zoneName] = new Application(zoneName, {
-        app: zoneConfig,
-        overrides: !disableOverrides ? (_c = this.overrides) == null ? void 0 : _c.config.applications[zoneName] : void 0
-      });
+    if (isMainConfig(config) && !this.defaultApplication) {
+      throw new MicrofrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
     }
     this.config = config;
-    this.name = config.name;
-    this.version = config.version;
     this.options = config.options;
-    this.$schema = config.$schema;
+    this.serialized = {
+      config,
+      overrides,
+      meta
+    };
+  }
+  static validate(config) {
+    const c = typeof config === "string" ? parse(config) : config;
+    if (isMainConfig(c)) {
+      validateConfigVersion(c.version);
+      validateConfigPaths(c.applications);
+      validateConfigDefaultApplication(c.applications);
+    }
+    return c;
+  }
+  static fromEnv({
+    meta,
+    cookies
+  }) {
+    return new MicrofrontendConfigIsomorphic({
+      config: parse(getConfigStringFromEnv()),
+      overrides: parseOverrides(cookies ?? []),
+      meta
+    });
   }
   isOverridesDisabled() {
     var _a, _b;
     return ((_b = (_a = this.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
   }
-  static getConfigFromEnv() {
-    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;
-  }
-  static fromEnv(_) {
-    throw new Error("Not implemented");
-  }
   getConfig() {
     return this.config;
   }
-  getAllApplications() {
-    return Object.values(this.zones);
+  getApplicationsByType() {
+    return {
+      defaultApplication: this.defaultApplication,
+      applications: Object.values(this.childApplications)
+    };
   }
-  getZone(name) {
-    const zone = this.zones[name];
-    if (!zone) {
+  getChildApplications() {
+    return Object.values(this.childApplications);
+  }
+  getAllApplications() {
+    return [
+      this.defaultApplication,
+      ...Object.values(this.childApplications)
+    ].filter(Boolean);
+  }
+  getApplication(name) {
+    var _a;
+    if (((_a = this.defaultApplication) == null ? void 0 : _a.name) === name) {
+      return this.defaultApplication;
+    }
+    const app = this.childApplications[name];
+    if (!app) {
       throw new MicrofrontendError(
         `Could not find microfrontends configuration for application "${name}"`,
         {
-          type: "zone",
+          type: "application",
           subtype: "not_found"
         }
       );
     }
-    return zone;
+    return app;
   }
   getApplicationByProjectId(projectId) {
-    return Object.values(this.zones).find(
-      (zone) => {
-        var _a;
-        return ((_a = zone.vercel) == null ? void 0 : _a.projectId) === projectId;
+    var _a, _b;
+    if (((_b = (_a = this.defaultApplication) == null ? void 0 : _a.vercel) == null ? void 0 : _b.projectId) === projectId) {
+      return this.defaultApplication;
+    }
+    return Object.values(this.childApplications).find(
+      (app) => {
+        var _a2;
+        return ((_a2 = app.vercel) == null ? void 0 : _a2.projectId) === projectId;
       }
     );
   }
-  getDefaultZone() {
-    const zone = Object.values(this.zones).find((z) => z.default);
-    if (!zone) {
+  /**
+   * Returns the default application. This can throw if the default application
+   * is undefined ( )
+   */
+  getDefaultApplication() {
+    if (!this.defaultApplication) {
       throw new MicrofrontendError(
-        `Could not find default zone in microfrontends configuration`,
+        `Could not find default application in microfrontends configuration`,
         {
-          type: "zone",
+          type: "application",
           subtype: "not_found"
         }
       );
     }
-    return zone;
+    return this.defaultApplication;
   }
   /**
    * Returns the configured port for the local proxy
@@ -454,671 +681,801 @@ var MicrofrontendConfigCommon = class {
    * NOTE: This is used when writing the config to disk and must always match the input Schema
    */
   toSchemaJson() {
-    const applications = {};
-    for (const [name, zone] of Object.entries(this.zones)) {
-      applications[name] = zone.serialize();
+    return this.serialized.config;
+  }
+  toClientConfig() {
+    const applications = Object.fromEntries(
+      Object.entries(this.childApplications).map(([name, application]) => [
+        name,
+        {
+          default: false,
+          routing: application.routing
+        }
+      ])
+    );
+    if (this.defaultApplication) {
+      applications[this.defaultApplication.name] = {
+        default: true
+      };
     }
-    return {
-      $schema: this.$schema,
-      name: this.name,
-      version: this.version,
-      options: this.options,
+    return new MicrofrontendConfigClient({
       applications
-    };
+    });
   }
   serialize() {
-    var _a;
-    const applications = {};
-    for (const [name, zone] of Object.entries(this.zones)) {
-      applications[name] = zone.serialize();
+    return this.serialized;
+  }
+};
+
+// 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
+  }) {
+    var _a, _b, _c;
+    super({ config, overrides, meta });
+    this.isMainConfig = true;
+    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+    let defaultApplication;
+    for (const [appId, appConfig] of Object.entries(config.applications)) {
+      const appOverrides = !disableOverrides ? (_c = this.overrides) == null ? void 0 : _c.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
+        });
+      }
     }
-    return {
-      config: {
-        name: this.name,
-        version: this.version,
-        applications,
-        options: this.options,
-        $schema: this.$schema
-      },
-      overrides: (_a = this.overrides) == null ? void 0 : _a.serialize()
-    };
+    if (!defaultApplication) {
+      throw new MicrofrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    this.defaultApplication = defaultApplication;
   }
-  write(_) {
-    throw new MicrofrontendError(
-      `Writing to file to disk requires using an instance of "MicrofrontendConfig".`,
-      { type: "config", subtype: "unsupported_operation" }
-    );
+};
+
+// 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/utils/get-output-file-path.ts
-import path2 from "node:path";
+// src/config/microfrontends/utils/find-repository-root.ts
+import fs from "node:fs";
+import path from "node:path";
+var GIT_DIRECTORY = ".git";
+function findRepositoryRoot(startDir) {
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== path.parse(currentDir).root) {
+    const gitPath = path.join(currentDir, GIT_DIRECTORY);
+    if (fs.existsSync(gitPath) && fs.statSync(gitPath).isDirectory()) {
+      return currentDir;
+    }
+    currentDir = path.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
+import { dirname } from "node:path";
+import { readFileSync } from "node:fs";
+import fg from "fast-glob";
+var configCache = {};
+function findPackagePathWithGlob({
+  repositoryRoot,
+  name
+}) {
+  try {
+    const packageJsonPaths = fg.globSync("**/package.json", {
+      cwd: repositoryRoot,
+      absolute: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    const matchingPaths = [];
+    for (const packageJsonPath2 of packageJsonPaths) {
+      const packageJsonContent = 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 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
+import { dirname as dirname2 } from "node:path";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { parse as parse2 } from "jsonc-parser";
+import fg2 from "fast-glob";
 
 // src/config/constants.ts
-var MFE_CONFIG_DEFAULT_FILE_PATH2 = "micro-frontends";
-var MFE_CONFIG_DEFAULT_FILE_NAME2 = "micro-frontends.config.json";
+var CONFIGURATION_FILENAMES = [
+  "microfrontends.jsonc",
+  "microfrontends.json"
+];
+
+// src/config/microfrontends/utils/find-default-package.ts
+var configCache2 = {};
+function findDefaultMicrofrontendsPackages({
+  repositoryRoot,
+  applicationName
+}) {
+  try {
+    const microfrontendsJsonPaths = fg2.globSync(
+      `**/{${CONFIGURATION_FILENAMES.join(",")}}`,
+      {
+        cwd: repositoryRoot,
+        absolute: true,
+        onlyFiles: true,
+        followSymbolicLinks: false,
+        ignore: ["**/node_modules/**", "**/.git/**"]
+      }
+    );
+    const matchingPaths = [];
+    for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
+      const microfrontendsJsonContent = readFileSync2(
+        microfrontendsJsonPath,
+        "utf-8"
+      );
+      const microfrontendsJson = parse2(microfrontendsJsonContent);
+      if (isMainConfig(microfrontendsJson) && microfrontendsJson.applications[applicationName]) {
+        matchingPaths.push(microfrontendsJsonPath);
+      }
+    }
+    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 dirname2(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
+import fs2 from "node:fs";
+import path2 from "node:path";
+function isMonorepo({
+  repositoryRoot
+}) {
+  try {
+    if (fs2.existsSync(path2.join(repositoryRoot, "pnpm-workspace.yaml"))) {
+      return true;
+    }
+    if (fs2.existsSync(path2.join(repositoryRoot, "vlt-workspaces.json"))) {
+      return true;
+    }
+    const packageJsonPath = path2.join(repositoryRoot, "package.json");
+    if (!fs2.existsSync(packageJsonPath)) {
+      return false;
+    }
+    const packageJson = JSON.parse(
+      fs2.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
+import fs3 from "node:fs";
+import path3 from "node:path";
+var PACKAGE_JSON = "package.json";
+function findPackageRoot(startDir) {
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== path3.parse(currentDir).root) {
+    const pkgJsonPath = path3.join(currentDir, PACKAGE_JSON);
+    if (fs3.existsSync(pkgJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path3.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
+import fs4 from "node:fs";
+import { join } from "node:path";
+function findConfig({ dir }) {
+  for (const filename of CONFIGURATION_FILENAMES) {
+    const maybeConfig = join(dir, filename);
+    if (fs4.existsSync(maybeConfig)) {
+      return maybeConfig;
+    }
+  }
+  return null;
+}
+
+// src/config/microfrontends/server/utils/get-output-file-path.ts
+import path4 from "node:path";
 
-// src/config/utils/get-output-file-path.ts
-function getOutputFilePath2() {
+// src/config/microfrontends/server/constants.ts
+var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
+var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
+
+// src/utils/is-vercel.ts
+function isVercel() {
+  return process.env.VERCEL === "1";
+}
+
+// src/config/microfrontends/server/utils/get-output-file-path.ts
+function getOutputFilePath() {
   if (isVercel()) {
-    return path2.join(
+    return path4.join(
       ".vercel",
-      MFE_CONFIG_DEFAULT_FILE_PATH2,
-      MFE_CONFIG_DEFAULT_FILE_NAME2
+      MFE_CONFIG_DEFAULT_FILE_PATH,
+      MFE_CONFIG_DEFAULT_FILE_NAME
     );
   }
-  return path2.join(MFE_CONFIG_DEFAULT_FILE_PATH2, MFE_CONFIG_DEFAULT_FILE_NAME2);
+  return path4.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
 }
 
-// src/config/validation.ts
-import { parse } from "jsonc-parser";
-import { pathToRegexp, parse as parsePathRegexp } from "path-to-regexp";
+// src/config/microfrontends/server/validation.ts
+import { parse as parse3 } from "jsonc-parser";
 import { Ajv } from "ajv";
 
-// src/config/types.ts
-var isDefaultApplicationConfig = (app) => app.default && typeof app.routing === "undefined";
-
 // schema/schema.json
 var schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
   $ref: "#/definitions/Config",
   definitions: {
     Config: {
+      anyOf: [
+        {
+          $ref: "#/definitions/MainConfig"
+        },
+        {
+          $ref: "#/definitions/ChildConfig"
+        }
+      ]
+    },
+    MainConfig: {
       type: "object",
       properties: {
-        version: {
-          type: "string"
-        },
         $schema: {
           type: "string"
         },
-        name: {
+        version: {
           type: "string",
-          description: 'Name for the micro-frontend site (eg. "vercel.com", "vercel-site" etc.).'
+          const: "2"
+        },
+        options: {
+          $ref: "#/definitions/Options"
+        },
+        remotes: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/Application"
+          },
+          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."
         },
         applications: {
-          $ref: "#/definitions/ApplicationConfigsById"
+          $ref: "#/definitions/ApplicationRouting",
+          description: "Mapping of application names to the routes that they host. Only needs to be defined in the application that owns the primary microfrontend domain"
+        }
+      },
+      required: ["applications", "version"],
+      additionalProperties: false
+    },
+    Options: {
+      type: "object",
+      properties: {
+        vercel: {
+          $ref: "#/definitions/VercelOptions",
+          description: "Micro-Frontends wide options for Vercel."
         },
-        options: {
-          $ref: "#/definitions/Options",
-          description: "Optional configuration for the entire micro-frontends setup."
+        localProxy: {
+          $ref: "#/definitions/LocalProxyOptions",
+          description: "Options for local proxy."
         }
       },
-      required: ["version", "applications"],
-      description: "Configuration for micro-frontend applications\n\nTODO: Add proxy configuration"
+      additionalProperties: false
     },
-    ApplicationConfigsById: {
+    VercelOptions: {
       type: "object",
-      additionalProperties: {
-        $ref: "#/definitions/ApplicationConfig"
-      }
+      properties: {
+        teamSlug: {
+          type: "string",
+          description: "Team slug for the Vercel team"
+        },
+        disableOverrides: {
+          type: "boolean",
+          description: "If you want to disable the overrides for the site. For example, if you are managing rewrites between applications externally, you may wish to disable the overrides on the toolbar as they will have no effect."
+        }
+      },
+      additionalProperties: false
+    },
+    LocalProxyOptions: {
+      type: "object",
+      properties: {
+        port: {
+          type: "number",
+          description: "The port number used by the local proxy server.\n\nThe default is `3024`."
+        }
+      },
+      additionalProperties: false
     },
-    ApplicationConfig: {
+    Application: {
       anyOf: [
         {
-          $ref: "#/definitions/DefaultApplicationConfig"
+          $ref: "#/definitions/DefaultApplication"
         },
         {
-          $ref: "#/definitions/CommonApplicationConfig"
+          $ref: "#/definitions/ChildApplication"
         }
-      ],
-      description: "A Micro-Frontend Deployment Target"
+      ]
     },
-    DefaultApplicationConfig: {
+    DefaultApplication: {
       type: "object",
       properties: {
-        default: {
-          type: "boolean",
-          const: true,
-          description: "The default application is used no other application is matched via the routing config"
-        },
-        routing: {
-          $ref: "#/definitions/Routing"
+        vercel: {
+          $ref: "#/definitions/Vercel"
         },
         development: {
-          type: "object",
-          properties: {
-            local: {
-              $ref: "#/definitions/HostConfig"
-            },
-            fallback: {
-              $ref: "#/definitions/HostConfig",
-              description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
-            },
-            task: {
-              type: "string",
-              description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
-            }
-          },
-          required: ["local"]
+          $ref: "#/definitions/Development"
         },
         production: {
           $ref: "#/definitions/HostConfig"
-        },
-        metadata: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        },
-        federation: {
-          type: "object",
-          properties: {
-            exposes: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  name: {
-                    type: "string",
-                    description: "The name of the module - should be used when importing the module from another application"
-                  },
-                  path: {
-                    type: "string",
-                    description: "Relative path to the module within its `application`"
-                  }
-                },
-                required: ["name", "path"]
-              },
-              description: "Modules that are exposed by this application"
-            },
-            uses: {
-              type: "array",
-              items: {
-                type: "string"
-              },
-              description: "Modules that are used by this application. Only the name of the module is required."
-            }
-          }
-        },
-        vercel: {
-          $ref: "#/definitions/Vercel"
         }
       },
-      required: ["default", "development", "production"]
+      required: ["production"],
+      additionalProperties: false
     },
-    Routing: {
+    Vercel: {
       type: "object",
       properties: {
-        assetPrefix: {
+        projectId: {
           type: "string",
-          description: "[assetPrefix] for the application"
-        },
-        matches: {
-          type: "array",
-          items: {
-            $ref: "#/definitions/PathGroup"
-          },
-          description: "Path expressions that are routed to this application."
+          description: "Vercel project ID"
         }
       },
-      required: ["matches"]
+      required: ["projectId"],
+      additionalProperties: false
     },
-    PathGroup: {
+    Development: {
       type: "object",
       properties: {
-        group: {
-          type: "string",
-          description: "Optional group name for the paths"
+        local: {
+          $ref: "#/definitions/LocalHostConfig"
         },
-        options: {
-          type: "object",
-          properties: {
-            flag: {
-              type: "string",
-              description: "flag name that can be used to enable/disable all paths in the group"
-            }
-          }
+        fallback: {
+          $ref: "#/definitions/HostConfig",
+          description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
         },
-        paths: {
-          type: "array",
-          items: {
-            type: "string"
-          }
+        task: {
+          type: "string",
+          description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
         }
       },
-      required: ["paths"]
+      additionalProperties: false
     },
-    HostConfig: {
+    LocalHostConfig: {
       type: "object",
+      additionalProperties: false,
       properties: {
-        protocol: {
-          type: "string",
-          enum: ["http", "https"],
-          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "https"'
-        },
         host: {
           type: "string",
           description: "The hostname or IP address of the server. This can be a domain name (e.g., `example.com`) or an IP address (e.g., `192.168.1.1`)."
         },
+        protocol: {
+          type: "string",
+          enum: ["http", "https"],
+          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "http" for local development, "https" for otherwise'
+        },
         port: {
           type: "number",
-          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS.\n\nThis field is optional and can be omitted if the default ports for the specified protocol are used"
+          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS."
         }
-      },
-      required: ["host"]
+      }
     },
-    Vercel: {
+    HostConfig: {
       type: "object",
       properties: {
-        projectId: {
-          type: "string",
-          description: "Vercel project ID"
-        },
-        projectName: {
+        protocol: {
           type: "string",
-          description: "Vercel project name (temporary until we can use project ID)"
+          enum: ["http", "https"],
+          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "http" for local development, "https" for otherwise'
         },
-        defaultRoute: {
+        host: {
           type: "string",
-          description: "The default route for the application. Used to render screenshots, favicons, and provide direct zone links"
+          description: "The hostname or IP address of the server. This can be a domain name (e.g., `example.com`) or an IP address (e.g., `192.168.1.1`)."
         },
-        routeSpeedInsightsToDefaultZone: {
-          type: "boolean",
-          description: "Whether to route Speed Insights to the default zone or each individual microfrontend."
+        port: {
+          type: "number",
+          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS."
         }
       },
-      required: ["projectId"]
+      required: ["host"],
+      additionalProperties: false
     },
-    CommonApplicationConfig: {
+    ChildApplication: {
       type: "object",
       properties: {
-        default: {
-          type: "boolean",
-          const: false,
-          description: "The default application is used no other application is matched via the routing config"
-        },
-        routing: {
-          $ref: "#/definitions/Routing"
+        vercel: {
+          $ref: "#/definitions/Vercel"
         },
         development: {
-          type: "object",
-          properties: {
-            local: {
-              $ref: "#/definitions/HostConfig"
-            },
-            fallback: {
-              $ref: "#/definitions/HostConfig",
-              description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
-            },
-            task: {
-              type: "string",
-              description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
-            }
-          },
-          required: ["local"]
+          $ref: "#/definitions/Development"
+        },
+        routing: {
+          $ref: "#/definitions/Routing",
+          description: "Groups of path expressions that are routed to this application."
         },
         production: {
           $ref: "#/definitions/HostConfig"
-        },
-        metadata: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        },
-        federation: {
-          type: "object",
-          properties: {
-            exposes: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  name: {
-                    type: "string",
-                    description: "The name of the module - should be used when importing the module from another application"
-                  },
-                  path: {
-                    type: "string",
-                    description: "Relative path to the module within its `application`"
-                  }
-                },
-                required: ["name", "path"]
-              },
-              description: "Modules that are exposed by this application"
-            },
-            uses: {
-              type: "array",
-              items: {
-                type: "string"
-              },
-              description: "Modules that are used by this application. Only the name of the module is required."
-            }
-          }
-        },
-        vercel: {
-          $ref: "#/definitions/Vercel"
         }
       },
-      required: ["default", "development", "production", "routing"]
-    },
-    Options: {
-      type: "object",
-      properties: {
-        vercel: {
-          $ref: "#/definitions/VercelOptions",
-          description: "Micro-Frontends wide options for Vercel."
-        },
-        localProxy: {
-          $ref: "#/definitions/LocalProxyOptions",
-          description: "Options for local proxy."
-        }
-      }
+      required: ["routing"],
+      additionalProperties: false
     },
-    VercelOptions: {
-      type: "object",
-      properties: {
-        previewDeploymentSuffix: {
-          type: "string",
-          description: "If your team uses a custom Preview Deployment Suffix, please specify it here. See https://vercel.com/docs/deployments/preview-deployment-suffix. The default is `vercel.app`."
-        },
-        teamSlug: {
-          type: "string",
-          description: "Team slug for the Vercel team"
-        },
-        disableOverrides: {
-          type: "boolean",
-          description: "If you want to disable the overrides for the site. For example, if you are managing rewrites between applications externally, you may wish to disable the overrides on the toolbar as they will have no effect."
-        }
-      }
-    },
-    LocalProxyOptions: {
-      type: "object",
-      properties: {
-        port: {
-          type: "number",
-          description: "The port number used by the local proxy server.\n\nThe default is `3024`."
-        }
-      }
-    }
-  }
-};
-
-// src/config/utils/load-schema.ts
-var SCHEMA = schema_default;
-
-// src/config/validation.ts
-var validateSchema = (configString) => {
-  const parsedConfig = parse(configString);
-  const ajv = new Ajv();
-  const validate = ajv.compile(SCHEMA);
-  const isValid = validate(parsedConfig);
-  if (!isValid) {
-    throw new MicrofrontendError(
-      `Invalid config: ${ajv.errorsText(validate.errors)}`,
-      { type: "config", subtype: "does_not_match_schema" }
-    );
-  }
-  return parsedConfig;
-};
-var SUPPORTED_VERSIONS2 = ["1"];
-var validateVersion = (version) => {
-  if (!SUPPORTED_VERSIONS2.includes(version)) {
-    throw new MicrofrontendError(
-      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS2.join(
-        ", "
-      )}`,
-      { type: "config", subtype: "unsupported_version" }
-    );
-  }
-};
-function validateMainPath(applicationConfigsById) {
-  for (const [id, app] of Object.entries(applicationConfigsById)) {
-    const { defaultRoute } = app.vercel ?? {};
-    if (!defaultRoute) {
-      continue;
-    }
-    if (isDefaultApplicationConfig(app)) {
-      const pathsWithApp = [];
-      for (const [otherId, otherApp] of Object.entries(
-        applicationConfigsById
-      )) {
-        if (isDefaultApplicationConfig(otherApp)) {
-          continue;
-        }
-        pathsWithApp.push({
-          id: otherId,
-          paths: otherApp.routing.matches.flatMap((match) => match.paths)
-        });
-      }
-      for (const { id: otherId, paths } of pathsWithApp) {
-        const isValid = paths.every((path3) => {
-          const matcher = pathToRegexp(path3);
-          return !matcher.test(defaultRoute);
-        });
-        if (!isValid) {
-          throw new MicrofrontendError(
-            `default route "${defaultRoute}" cannot be used for "${id}" because it is matched by "${otherId}"`,
-            { type: "config", subtype: "invalid_main_path" }
-          );
-        }
-      }
-    } else {
-      const allPaths = app.routing.matches.flatMap((match) => match.paths);
-      const isValid = allPaths.some((path3) => {
-        const matcher = pathToRegexp(path3);
-        return matcher.test(defaultRoute);
-      });
-      if (!isValid) {
-        throw new MicrofrontendError(
-          `default route "${defaultRoute}" is not included by the routing config for application "${id}"`,
-          { type: "config", subtype: "invalid_main_path" }
-        );
-      }
-    }
-  }
-}
-var validatePaths = (applicationConfigsById) => {
-  const pathsByApplicationId = /* @__PURE__ */ new Map();
-  const errors = [];
-  for (const [id, app] of Object.entries(applicationConfigsById)) {
-    if (isDefaultApplicationConfig(app)) {
-      continue;
-    }
-    for (const pathMatch of app.routing.matches) {
-      for (const path3 of pathMatch.paths) {
-        const maybeError = validatePathExpression(path3);
-        if (maybeError) {
-          errors.push(maybeError);
-        }
-        const existing = pathsByApplicationId.get(path3);
-        if (existing) {
-          existing.applications.push(id);
-        } else {
-          pathsByApplicationId.set(path3, {
-            applications: [id],
-            matcher: pathToRegexp(path3),
-            applicationId: id
-          });
-        }
-      }
-    }
-  }
-  const entries = Array.from(pathsByApplicationId.entries());
-  entries.forEach(([path3, { applications: ids, matcher, applicationId }]) => {
-    if (ids.length > 1) {
-      errors.push(
-        `Duplicate path "${path3}" for applications "${ids.join(", ")}"`
-      );
-    }
-    entries.forEach(
-      ([
-        matchPath,
-        { applications: matchIds, applicationId: matchApplicationId }
-      ]) => {
-        if (path3 === matchPath) {
-          return;
-        }
-        if (applicationId === matchApplicationId) {
-          return;
-        }
-        if (matcher.test(matchPath)) {
-          const source = `"${path3}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
-          const destination = `"${matchPath}" of application${matchIds.length > 0 ? "s" : ""} ${matchIds.join(", ")}`;
-          errors.push(
-            `Overlapping path detected between ${source} and ${destination}`
-          );
-        }
-      }
-    );
-  });
-  if (errors.length) {
-    throw new MicrofrontendError(`Invalid paths: ${errors.join(", ")}`, {
-      type: "config",
-      subtype: "conflicting_paths"
-    });
-  }
-};
-var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
-function validatePathExpression(path3) {
-  const tokens = parsePathRegexp(path3);
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (token === void 0) {
-      return `token ${i} in ${path3} is undefined, this shouldn't happen`;
-    }
-    if (typeof token !== "string") {
-      if (token.pattern !== PATH_DEFAULT_PATTERN) {
-        return `Path ${path3} cannot use a regular expression wildcard`;
-      }
-      if (token.prefix !== "/") {
-        return `Wildcard :${token.name} must be immediately after a / in ${path3}`;
-      }
-      if (token.suffix) {
-        return `Wildcard suffix on :${token.name} is not allowed. Suffixes are not supported`;
+    Routing: {
+      type: "array",
+      items: {
+        $ref: "#/definitions/PathGroup"
       }
-      if (token.modifier && i !== tokens.length - 1) {
-        return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path3}. Modifiers are only allowed in the last path component`;
+    },
+    PathGroup: {
+      type: "object",
+      properties: {
+        group: {
+          type: "string",
+          description: "Optional group name for the paths"
+        },
+        flag: {
+          type: "string",
+          description: "flag name that can be used to enable/disable all paths in the group"
+        },
+        paths: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["paths"],
+      additionalProperties: false
+    },
+    ApplicationRouting: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/definitions/Application"
       }
-    }
-  }
-  return void 0;
-}
-var validateDefaults = (applicationConfigsById) => {
-  const defaultApplicationIds = Object.entries(applicationConfigsById).reduce((acc, [id, app]) => app.default ? [...acc, id] : acc, []);
-  if (defaultApplicationIds.length === 0) {
-    throw new MicrofrontendError(
-      `No default application found. At least one application must be marked as default.`,
-      { type: "config", subtype: "no_default_application" }
-    );
-  }
-  if (defaultApplicationIds.length > 1) {
-    throw new MicrofrontendError(
-      `Only one default application is allowed. Found ${defaultApplicationIds.join(", ")}.`,
-      { type: "config", subtype: "multiple_default_applications" }
-    );
-  }
-};
-var validateOptions = (options) => {
-  var _a;
-  if ((_a = options == null ? void 0 : options.vercel) == null ? void 0 : _a.previewDeploymentSuffix) {
-    if (!/^[a-zA-Z]{2,}\.[a-zA-Z]{2,}$/.test(
-      options.vercel.previewDeploymentSuffix
-    )) {
-      throw new MicrofrontendError(
-        `Invalid preview deployment suffix: ${options.vercel.previewDeploymentSuffix}. Should have be formatted like "vercel.app".`,
-        { type: "config", subtype: "invalid_preview_deployment_suffix" }
-      );
+    },
+    ChildConfig: {
+      type: "object",
+      properties: {
+        $schema: {
+          type: "string"
+        },
+        version: {
+          type: "string",
+          const: "2"
+        },
+        options: {
+          $ref: "#/definitions/Options"
+        },
+        remotes: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/Application"
+          },
+          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."
+        },
+        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", "version"],
+      additionalProperties: false
     }
   }
 };
 
-// src/config/utils/convert.ts
-function convertV1RoutingToV2Routing(routing) {
-  return routing.matches.map((group) => {
-    var _a;
-    return {
-      group: group.group,
-      flag: (_a = group.options) == null ? void 0 : _a.flag,
-      paths: group.paths
-    };
-  });
-}
-function convertV1ApplicationToV2Application(application) {
-  const common = {
-    production: application.production,
-    development: application.development,
-    vercel: application.vercel
-  };
-  if (application.default) {
-    return common;
+// src/config/schema/utils/load.ts
+var SCHEMA = schema_default;
+
+// src/config/microfrontends/server/validation.ts
+function validateSchema(configString) {
+  const parsedConfig = parse3(configString);
+  const ajv = new Ajv();
+  const validate = ajv.compile(SCHEMA);
+  const isValid = validate(parsedConfig);
+  if (!isValid) {
+    throw new MicrofrontendError(
+      `Invalid config: ${ajv.errorsText(validate.errors)}`,
+      { type: "config", subtype: "does_not_match_schema" }
+    );
   }
-  return {
-    ...common,
-    routing: convertV1RoutingToV2Routing(application.routing)
-  };
+  return parsedConfig;
 }
-function convertV1ConfigToV2Config(config, fromApp) {
-  if (!config.applications[fromApp]) {
-    throw new Error(`Application "${fromApp}" not found in the config`);
-  }
-  const common = {
-    version: "2",
-    options: config.options
-  };
-  if (config.applications[fromApp].default) {
-    return {
-      ...common,
-      applications: Object.fromEntries(
-        Object.entries(config.applications).map(([id, application]) => [
-          id,
-          convertV1ApplicationToV2Application(application)
-        ])
+
+// src/config/microfrontends/server/index.ts
+var MicrofrontendsServer = class extends Microfrontends {
+  /**
+   * Writes the configuration to a file.
+   */
+  writeConfig(opts = {
+    pretty: true
+  }) {
+    const outputPath = getOutputFilePath();
+    fs5.mkdirSync(dirname3(outputPath), { recursive: true });
+    fs5.writeFileSync(
+      outputPath,
+      JSON.stringify(
+        this.config.toSchemaJson(),
+        null,
+        opts.pretty ?? true ? 2 : void 0
       )
-    };
-  }
-  const defaultApplication = Object.entries(config.applications).find(
-    ([, application]) => application.default
-  );
-  if (!defaultApplication) {
-    throw new Error("No default application found in the config");
+    );
   }
-  return {
-    ...common,
-    partOf: defaultApplication[0]
-  };
-}
-
-// src/config/utils/write-file.ts
-import fs from "node:fs";
-import { dirname } from "node:path";
-function writeFile(outputPath, config, prettify) {
-  fs.mkdirSync(dirname(outputPath), { recursive: true });
-  fs.writeFileSync(
-    outputPath,
-    JSON.stringify(config, null, prettify ? 2 : void 0)
-  );
-}
-
-// src/config/microfrontend-config.ts
-var MicrofrontendConfig = class extends MicrofrontendConfigCommon {
-  static validate(configString) {
-    const config = validateSchema(configString);
-    validateVersion(config.version);
-    validatePaths(config.applications);
-    validateMainPath(config.applications);
-    validateDefaults(config.applications);
-    validateOptions(config.options);
-    return config;
+  // --------- Static Methods ---------
+  /**
+   * Generates a MicrofrontendsServer instance from an unknown object.
+   */
+  static fromUnknown({
+    config,
+    cookies,
+    meta
+  }) {
+    const overrides = cookies ? parseOverrides(cookies) : void 0;
+    if (typeof config === "string") {
+      return new MicrofrontendsServer({
+        config: MicrofrontendsServer.validate(config),
+        overrides,
+        meta
+      });
+    }
+    if (typeof config === "object") {
+      return new MicrofrontendsServer({
+        config,
+        overrides,
+        meta
+      });
+    }
+    throw new MicrofrontendError(
+      "Invalid config: must be a string or an object",
+      { type: "config", subtype: "does_not_match_schema" }
+    );
   }
+  /**
+   * Generates a MicrofrontendsServer instance from the environment.
+   * Uses additional validation that is only available when in a node runtime
+   */
   static fromEnv({
-    cookies
+    cookies,
+    meta
   }) {
-    return new MicrofrontendConfigCommon({
-      config: MicrofrontendConfig.validate(
-        MicrofrontendConfigCommon.getConfigFromEnv()
-      ),
-      overrides: Overrides.parseOverrides(cookies)
+    return new MicrofrontendsServer({
+      config: MicrofrontendsServer.validate(getConfigStringFromEnv()),
+      overrides: parseOverrides(cookies),
+      meta
     });
   }
+  /**
+   * Validates the configuration against the JSON schema
+   */
+  static validate(config) {
+    if (typeof config === "string") {
+      const c = validateSchema(config);
+      return c;
+    }
+    return config;
+  }
+  /**
+   * Looks up the configuration by inferring the package root and looking for a microfrontends config file. If a file is not found,
+   * it will look for a package in the repository with a microfrontends file that contains the current application
+   * and use that configuration.
+   *
+   * This can return either a Child or Main configuration.
+   */
+  static infer({
+    directory,
+    filePath,
+    meta,
+    cookies,
+    options
+  } = {}) {
+    if (filePath && meta) {
+      return MicrofrontendsServer.fromFile({
+        filePath,
+        cookies,
+        meta,
+        options
+      });
+    }
+    try {
+      const packageRoot = findPackageRoot(directory);
+      const packageJsonPath = join2(packageRoot, "package.json");
+      const packageJson = JSON.parse(
+        fs5.readFileSync(packageJsonPath, "utf-8")
+      );
+      if (!packageJson.name) {
+        throw new Error(`No name found in package.json at ${packageJsonPath}`);
+      }
+      const configMeta = meta ?? { fromApp: packageJson.name };
+      const maybeConfig = findConfig({ dir: packageRoot });
+      if (maybeConfig) {
+        return MicrofrontendsServer.fromFile({
+          filePath: maybeConfig,
+          cookies,
+          meta: configMeta,
+          options
+        });
+      }
+      const repositoryRoot = findRepositoryRoot();
+      const isMonorepo2 = isMonorepo({ repositoryRoot });
+      if (isMonorepo2) {
+        const defaultPackage = findDefaultMicrofrontendsPackage({
+          repositoryRoot,
+          applicationName: packageJson.name
+        });
+        const maybeConfigFromDefault = findConfig({ dir: defaultPackage });
+        if (maybeConfigFromDefault) {
+          return MicrofrontendsServer.fromFile({
+            filePath: maybeConfigFromDefault,
+            cookies,
+            meta: configMeta,
+            options
+          });
+        }
+      }
+      throw new Error("Unable to infer");
+    } catch (e) {
+      throw new MicrofrontendError(
+        "Unable to infer microfrontends configuration",
+        { type: "config", subtype: "inference_failed" }
+      );
+    }
+  }
+  /*
+   * Generates a MicrofrontendsServer instance from a file.
+   */
   static fromFile({
-    filePath
+    filePath,
+    cookies,
+    meta,
+    options
   }) {
     try {
-      const config = fs2.readFileSync(filePath, "utf-8");
-      return new MicrofrontendConfig({
-        config: MicrofrontendConfig.validate(config)
+      const configJson = fs5.readFileSync(filePath, "utf-8");
+      const config = MicrofrontendsServer.validate(configJson);
+      if (!isMainConfig(config) && (options == null ? void 0 : 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
       });
     } catch (e) {
       throw MicrofrontendError.handle(e, {
@@ -1126,20 +1483,41 @@ var MicrofrontendConfig = class extends MicrofrontendConfigCommon {
       });
     }
   }
-  /**
-   * Writes the configuration to a file.
+  /*
+   * Generates a MicrofrontendMainConfig instance from a file.
    */
-  write(fromApp, opts = {}) {
-    const { pretty = true, versions = ["v1", "v2"] } = opts;
-    const config = this.toSchemaJson();
-    if (versions.includes("v1")) {
-      const outputPath = getOutputFilePath2();
-      writeFile(outputPath, config, pretty);
-    }
-    if (versions.includes("v2")) {
-      const outputPath = getOutputFilePath();
-      const v2Config = convertV1ConfigToV2Config(config, fromApp);
-      writeFile(outputPath, v2Config, pretty);
+  static fromMainConfigFile({
+    filePath,
+    overrides
+  }) {
+    try {
+      const config = fs5.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(
+          `No default application found. At least one application needs to be the default by omitting routing.`,
+          { type: "config", subtype: "no_default_application" }
+        );
+      }
+      return new MicrofrontendsServer({
+        config: validatedConfig,
+        overrides,
+        meta: { fromApp: defaultApplication }
+      });
+    } catch (e) {
+      throw MicrofrontendError.handle(e, {
+        fileName: filePath
+      });
     }
   }
 };
@@ -1155,19 +1533,19 @@ function displayLocalProxyInfo(port) {
 
 // src/next/config/transforms/asset-prefix.ts
 function transform(args) {
-  var _a;
-  const { next, zone } = args;
-  if (!((_a = zone.routing) == null ? void 0 : _a.assetPrefix)) {
+  const { next, app } = args;
+  if (app.isDefault()) {
     return {
       next
     };
   }
-  if (next.assetPrefix !== void 0 && next.assetPrefix !== zone.routing.assetPrefix) {
-    throw new Error(
-      `"assetPrefix" already set. Overwriting with "${zone.name}"`
+  if (next.assetPrefix !== void 0 && next.assetPrefix !== app.getAssetPrefix()) {
+    console.log(
+      `"assetPrefix" already set. This route must be manually configured in your microfrontend.json file.`
     );
+  } else {
+    next.assetPrefix = `/${app.getAssetPrefix()}`;
   }
-  next.assetPrefix = `/${zone.routing.assetPrefix}`;
   return {
     next
   };
@@ -1191,8 +1569,8 @@ function transform2(args) {
 
 // src/next/config/transforms/headers.ts
 function transform3(args) {
-  const { next, zone } = args;
-  if (zone.isDefault()) {
+  const { next, app } = args;
+  if (app.isDefault()) {
     return {
       next
     };
@@ -1203,7 +1581,11 @@ function transform3(args) {
       headers: [
         {
           key: "X-Vercel-Zone",
-          value: zone.name
+          value: app.name
+        },
+        {
+          key: "X-Vercel-MFE-App",
+          value: app.name
         }
       ]
     },
@@ -1242,82 +1624,39 @@ function transform3(args) {
   };
 }
 
-// src/routing/get-preview-domain.ts
-import { createHash } from "node:crypto";
-var DOMAIN_SIZE = 253;
-var DOMAIN_LABEL_SIZE = 63;
-function getMaxLabelLength(domain) {
-  return Math.min(DOMAIN_SIZE - domain.length - 1, DOMAIN_LABEL_SIZE);
-}
-function parseBranchUrl(branchUrl) {
-  const branchUrlParts = branchUrl.split(".");
-  if (branchUrlParts.length < 3) {
-    throw new Error(`Could not parse Vercel branch URL "${branchUrl}"`);
+// src/routing/get-domain-from-environment.ts
+function getDomainFromEnvironment({
+  app,
+  target
+}) {
+  var _a;
+  const mfeProjects = JSON.parse(
+    process.env.VERCEL_MICROFRONTENDS_PROJECTS ?? "[]"
+  );
+  if (mfeProjects.length === 0) {
+    throw new Error("Missing related microfrontends project information");
   }
-  const domain = [branchUrlParts[1], branchUrlParts[2]].join(".");
-  return {
-    // biome-ignore lint/style/noNonNullAssertion: Ignored using `--suppress`
-    label: branchUrlParts[0],
-    domain
-  };
-}
-function getDomainSuffix(branchUrl, vercelUrl) {
-  const branchLabelParts = parseBranchUrl(branchUrl).label.split("-");
-  const vercelUrlLabelParts = parseBranchUrl(vercelUrl).label.split("-");
-  const suffixParts = [];
-  for (let i = 1; i < branchLabelParts.length; i++) {
-    if (branchLabelParts.at(-1 * i) === vercelUrlLabelParts.at(-1 * i)) {
-      suffixParts.push(branchLabelParts.at(-1 * i) ?? "");
-    }
+  if (!((_a = app.vercel) == null ? void 0 : _a.projectId)) {
+    throw new Error(`Missing applications[${app.name}].vercel.projectId`);
   }
-  return suffixParts.reverse().filter(Boolean).join("-");
-}
-function getPreviewDomain(zone) {
-  var _a;
-  const targetVercelProjectName = (_a = zone.vercel) == null ? void 0 : _a.projectName;
-  if (!targetVercelProjectName) {
+  const vercelProject = mfeProjects.find(
+    (p) => {
+      var _a2;
+      return p.project.id === ((_a2 = app.vercel) == null ? void 0 : _a2.projectId);
+    }
+  );
+  if (!vercelProject) {
     throw new Error(
-      `Missing Vercel project configuration for application "${zone.name}"`
+      `Missing related microfrontends project information for application "${app.name}"`
     );
   }
-  const { VERCEL_GIT_COMMIT_REF, VERCEL_BRANCH_URL, VERCEL_URL } = process.env;
-  if (VERCEL_GIT_COMMIT_REF && VERCEL_BRANCH_URL && VERCEL_URL) {
-    const branchUrlParts = parseBranchUrl(VERCEL_BRANCH_URL);
-    const { domain } = branchUrlParts;
-    const stagingSuffix = domain !== "vercel.sh" ? getDomainSuffix(VERCEL_BRANCH_URL, VERCEL_URL) : "";
-    const gitBranch = `git-${VERCEL_GIT_COMMIT_REF.toLocaleLowerCase()}`;
-    const gitBranchForHash = `git-${VERCEL_GIT_COMMIT_REF}`;
-    const urlSafeBranch = makeUrlSafe(gitBranch);
-    const urlSafeProjectName = makeUrlSafe(targetVercelProjectName);
-    const maxLabelLength = getMaxLabelLength(domain);
-    const label = [urlSafeProjectName, urlSafeBranch, stagingSuffix].filter(Boolean).join("-");
-    if (label.length > maxLabelLength) {
-      let newLabel = makeUrlSafe(stagingSuffix).slice(0, maxLabelLength);
-      const hash = createHash("sha256").update(`${gitBranchForHash}${targetVercelProjectName}`).digest("hex").slice(0, 6);
-      newLabel = [hash, newLabel].filter(Boolean).join("-");
-      const projectNamePart = makeUrlSafe(
-        urlSafeProjectName.slice(0, maxLabelLength - newLabel.length - 1 - 4)
-      );
-      const branchPart = makeUrlSafe(
-        urlSafeBranch.slice(
-          0,
-          Math.max(
-            0,
-            maxLabelLength - (newLabel.length + projectNamePart.length) - 2
-          )
-        )
-      );
-      if (branchPart.length >= 3) {
-        newLabel = [branchPart, newLabel].filter(Boolean).join("-");
-      }
-      if (projectNamePart) {
-        newLabel = [projectNamePart, newLabel].filter(Boolean).join("-");
-      }
-      return `https://${newLabel}.${domain}`;
-    }
-    return `https://${label}.${domain}`;
+  const domain = target === "preview" && vercelProject.preview.branch ? vercelProject.preview.branch : vercelProject.production.alias ?? vercelProject.production.url;
+  if (!domain) {
+    throw new Error(
+      `Missing domain for target "${target}" in application "${app.name}"`
+    );
   }
-  return zone.production.toString();
+  return domain.startsWith("https://") ? domain : `https://${domain}`;
 }
 
 // src/routing/get-domain-for-current-environment.ts
@@ -1333,34 +1672,45 @@ ${line}
 `);
   }
 }
-function getDomainForCurrentEnvironment(zone, opts = {}) {
+function getCurrentEnvironment() {
+  const isDevelopment = !process.env.VERCEL_ENV || process.env.VERCEL_ENV === "development";
+  const isPreview = process.env.VERCEL_ENV === "preview";
+  const isProduction2 = process.env.VERCEL_ENV === "production";
+  if (isDevelopment) {
+    return { group: "development" };
+  } else if (isProduction2) {
+    return { group: "production" };
+  } else if (isPreview) {
+    return { group: "preview" };
+  }
+  return { group: "custom", name: process.env.VERCEL_ENV };
+}
+function getDomainForCurrentEnvironment(config, appName, opts = {}) {
   var _a;
-  if (!opts.ignoreOverride && ((_a = zone.overrides) == null ? void 0 : _a.environment)) {
-    return zone.overrides.environment.toString();
-  }
-  const zoneName = zone.name;
-  if (!process.env.VERCEL_ENV || process.env.VERCEL_ENV === "development") {
-    const domain = process.env.NODE_ENV === "test" ? zone.development.local.toString() : zone.production.toString();
-    debugDomains(zoneName, "development", domain);
-    return domain;
-  } else if (process.env.VERCEL_ENV === "production") {
-    const domain = zone.production.toString();
-    debugDomains(zoneName, "production", domain);
-    return domain;
-  } else if (process.env.VERCEL_ENV === "preview") {
-    const MFE_PREVIEW_DOMAINS = JSON.parse(
-      process.env.MFE_PREVIEW_DOMAINS ?? "{}"
-    );
-    if (MFE_PREVIEW_DOMAINS[zoneName]) {
-      debugDomains(zoneName, "preview", MFE_PREVIEW_DOMAINS[zoneName]);
-      return MFE_PREVIEW_DOMAINS[zoneName];
+  const app = config.getApplication(appName);
+  if (!opts.ignoreOverride && ((_a = app.overrides) == null ? void 0 : _a.environment)) {
+    return app.overrides.environment.toString();
+  }
+  const { group } = getCurrentEnvironment();
+  const productionHost = config.getDefaultApplication().production.toString();
+  switch (group) {
+    case "development": {
+      const domain = ["test", "development"].includes(process.env.NODE_ENV) ? app.development.local.toString() : productionHost;
+      debugDomains(appName, "development", domain);
+      return domain;
     }
-    throw new Error(
-      `Could not find preview domain for application "${zoneName}"`
-    );
+    case "preview": {
+      return getDomainFromEnvironment({ app, target: "preview" });
+    }
+    case "production": {
+      return getDomainFromEnvironment({ app, target: "production" });
+    }
+    case "custom":
+      console.warn(
+        `Custom environments are not supported in getDomainForCurrentEnvironment`
+      );
+      return productionHost;
   }
-  debugDomains(zoneName, process.env.VERCEL_ENV, zone.production.toString());
-  return zone.production.toString();
 }
 
 // src/next/config/transforms/rewrites.ts
@@ -1382,11 +1732,11 @@ ${table}
 `);
   }
 }
-function pathToRewrites(path3) {
+function pathToRewrites(path5) {
   var _a;
   const regex = /(?<base>^.+)\/:.+\*$/;
-  const match = regex.exec(path3);
-  const paths = [path3];
+  const match = regex.exec(path5);
+  const paths = [path5];
   if ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.base) {
     paths.unshift(match.groups.base);
   }
@@ -1415,42 +1765,39 @@ function rewritesMapToArr(rewrites) {
   });
 }
 function transform4(args) {
-  const { next, microfrontend, zone } = args;
+  const { next, microfrontend, app } = args;
   const buildBeforeFiles = () => {
-    var _a, _b, _c, _d;
     const rewrites = /* @__PURE__ */ new Map();
-    if ((_a = zone.routing) == null ? void 0 : _a.assetPrefix) {
-      rewrites.set(`/${zone.routing.assetPrefix}/_next/:path+`, {
+    if (!app.isDefault()) {
+      rewrites.set(`/${app.getAssetPrefix()}/_next/:path+`, {
         destination: {
           pathname: `/_next/:path+`
         }
       });
-      if (!((_b = zone.vercel) == null ? void 0 : _b.routeSpeedInsightsToDefaultZone)) {
-        rewrites.set(`/${zone.routing.assetPrefix}/_vercel/:path*`, {
+      rewrites.set(`/${app.getAssetPrefix()}/.well-known/vercel/flags`, {
+        destination: {
+          pathname: `/.well-known/vercel/flags`
+        }
+      });
+      if (process.env.VERCEL_MICROFRONTENDS_CONSOLIDATE_SPEED_INSIGHTS === "1") {
+        rewrites.set(`/${app.getAssetPrefix()}/_vercel/:path*`, {
           destination: { pathname: "/_vercel/:path*" }
         });
       }
-    }
-    if (zone.isDefault()) {
-      for (const [_, z] of Object.entries(microfrontend.zones)) {
-        if (zone.name === z.name) {
-          continue;
-        }
-        const { routing } = z;
-        if (!routing) {
-          continue;
-        }
-        const domain = process.env.VERCEL_ENV === "preview" ? getPreviewDomain(z) : getDomainForCurrentEnvironment(z);
-        if ((_c = z.routing) == null ? void 0 : _c.assetPrefix) {
-          rewrites.set(`/${z.routing.assetPrefix}/:path+`, {
-            destination: {
-              domain,
-              pathname: `/${z.routing.assetPrefix}/:path+`
-            }
-          });
-        }
-        for (const group of routing.matches) {
-          if ((_d = group.options) == null ? void 0 : _d.flag) {
+    } else if (microfrontend instanceof MicrofrontendMainConfig) {
+      for (const [_, a] of Object.entries(
+        microfrontend.getChildApplications()
+      )) {
+        const { routing } = a;
+        const domain = getDomainForCurrentEnvironment(microfrontend, a.name);
+        rewrites.set(`/${a.getAssetPrefix()}/:path+`, {
+          destination: {
+            domain,
+            pathname: `/${a.getAssetPrefix()}/:path+`
+          }
+        });
+        for (const group of routing) {
+          if (group.flag) {
             continue;
           } else {
             for (const source of group.paths) {
@@ -1464,7 +1811,6 @@ function transform4(args) {
           }
         }
       }
-    } else {
     }
     return rewritesMapToArr(rewrites);
   };
@@ -1501,17 +1847,44 @@ function transform4(args) {
 }
 
 // src/next/config/transforms/server-actions.ts
+function debugRewrites2(allowedOrigins) {
+  if (process.env.MFE_DEBUG === "true" && allowedOrigins) {
+    const indent = " ".repeat(4);
+    const header = "server actions allowed origins";
+    const separator = "\u23AF".repeat(header.length);
+    const maxSourceLength = Math.max(
+      ...allowedOrigins.map((key) => key.length)
+    );
+    const table = allowedOrigins.map((origin, idx) => {
+      const paddedSource = origin.padEnd(maxSourceLength);
+      return `${indent} ${idx + 1}. ${paddedSource}`;
+    }).join("\n");
+    console.log(`${indent}${header}
+${indent}${separator}
+${table}
+`);
+  }
+}
 var formatDomainForServerAction = (domain) => domain.replace(/https?:\/\//, "");
 function transform5(args) {
-  var _a;
-  const { next, zone, microfrontend } = args;
-  const zonesToAllow = [
+  var _a, _b;
+  const { next, app, microfrontend } = args;
+  if (microfrontend instanceof MicrofrontendChildConfig) {
+    console.warn(
+      "server actions transform requires the full config - skipping"
+    );
+    return {
+      next
+    };
+  }
+  const defaultApplication = microfrontend.getDefaultApplication();
+  const appsToAllow = [
     // this zone - this is included by default unless allowedOrigins is overridden (which we are)
     // so we re-add it here.
-    zone,
+    app,
     // this is the default zone for the microfrontend. Allow child zones to call server actions
     // that are in the default zone.
-    microfrontend.getDefaultZone()
+    defaultApplication
   ];
   const existingServerActionConfig = (_a = next.experimental) == null ? void 0 : _a.serverActions;
   next.experimental = {
@@ -1520,15 +1893,23 @@ function transform5(args) {
       ...existingServerActionConfig,
       allowedOrigins: Array.from(
         /* @__PURE__ */ new Set([
+          // existing
           ...(existingServerActionConfig == null ? void 0 : existingServerActionConfig.allowedOrigins) ?? [],
-          ...zonesToAllow.flatMap((z) => [
-            formatDomainForServerAction(z.production.toString()),
-            formatDomainForServerAction(getDomainForCurrentEnvironment(z))
+          // this deployments host
+          ...process.env.VERCEL_URL ? [formatDomainForServerAction(process.env.VERCEL_URL)] : [],
+          // default application host
+          formatDomainForServerAction(defaultApplication.production.toString()),
+          // environment specific microfrontend hosts
+          ...appsToAllow.flatMap((a) => [
+            formatDomainForServerAction(
+              getDomainForCurrentEnvironment(microfrontend, a.name)
+            )
           ])
         ])
       )
     }
   };
+  debugRewrites2((_b = next.experimental.serverActions) == null ? void 0 : _b.allowedOrigins);
   return {
     next
   };
@@ -1537,14 +1918,6 @@ function transform5(args) {
 // src/next/config/transforms/webpack.ts
 function transform6(args) {
   const { next, microfrontend } = args;
-  const previewDomains = process.env.VERCEL_ENV === "preview" ? microfrontend.getAllApplications().reduce(
-    (obj, app) => {
-      obj[app.name] = getPreviewDomain(app);
-      return obj;
-    },
-    // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter -- needed to satisfy TSC
-    {}
-  ) : {};
   const configWithWebpack = {
     ...next,
     webpack(cfg, context) {
@@ -1553,8 +1926,7 @@ function transform6(args) {
       if (isServer || nextRuntime === "edge") {
         config.plugins.push(
           new wpFromNext.EnvironmentPlugin({
-            MFE_CONFIG: JSON.stringify(microfrontend.serialize()),
-            MFE_PREVIEW_DOMAINS: JSON.stringify(previewDomains)
+            MFE_CONFIG: JSON.stringify(microfrontend.serialize())
           })
         );
       }
@@ -1594,21 +1966,6 @@ var transforms = {
   webpack: transform6
 };
 
-// src/config/client/client-config.ts
-function getConfigForClient(config) {
-  return {
-    applications: Object.fromEntries(
-      Object.entries(config.applications).map(([name, application]) => [
-        name,
-        {
-          default: application.default,
-          routing: application.routing
-        }
-      ])
-    )
-  };
-}
-
 // src/next/config/env.ts
 function debugEnv(env) {
   if (process.env.MFE_DEBUG === "true") {
@@ -1627,32 +1984,18 @@ ${table}
   }
 }
 function setEnvironment({
-  zone,
-  config
+  app,
+  microfrontends
 }) {
-  var _a, _b, _c, _d;
-  const previewDomains = process.env.VERCEL_ENV === "preview" ? config.getAllApplications().reduce(
-    (obj, app) => {
-      obj[app.name] = getPreviewDomain(app);
-      return obj;
-    },
-    // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter -- needed to satisfy TSC
-    {}
-  ) : {};
   const clientEnvs = {
-    NEXT_PUBLIC_MFE_CURRENT_APPLICATION: zone.name,
+    NEXT_PUBLIC_MFE_CURRENT_APPLICATION: app.name,
     NEXT_PUBLIC_MFE_CLIENT_CONFIG: JSON.stringify(
-      getConfigForClient(config.getConfig())
-    ),
-    ...((_a = zone.vercel) == null ? void 0 : _a.routeSpeedInsightsToDefaultZone) && ((_b = zone.routing) == null ? void 0 : _b.assetPrefix) ? {} : {
-      NEXT_PUBLIC_SPEED_INSIGHTS_BASEPATH: (_c = zone.routing) == null ? void 0 : _c.assetPrefix,
-      NEXT_PUBLIC_WEB_ANALYTICS_BASEPATH: (_d = zone.routing) == null ? void 0 : _d.assetPrefix
-    }
+      microfrontends.config.toClientConfig().serialize()
+    )
   };
   const serverEnvs = {
-    MFE_CURRENT_APPLICATION: zone.name,
-    MFE_PREVIEW_DOMAINS: JSON.stringify(previewDomains),
-    MFE_CONFIG: JSON.stringify(config.getConfig())
+    MFE_CURRENT_APPLICATION: app.name,
+    MFE_CONFIG: JSON.stringify(microfrontends.config.getConfig())
   };
   const allEnvs = { ...clientEnvs, ...serverEnvs };
   for (const [key, value] of Object.entries(allEnvs)) {
@@ -1671,37 +2014,12 @@ function isProduction(opts) {
   }
   return process.env.VERCEL_ENV === "production";
 }
-function getConfigPath(opts) {
-  var _a;
-  if (opts == null ? void 0 : opts.configPath) {
-    return { configPath: opts.configPath };
-  }
-  try {
-    const vercelJsonString = fs3.readFileSync("./vercel.json", "utf-8");
-    const vercelJson = JSON.parse(vercelJsonString);
-    if (!((_a = vercelJson.microFrontends) == null ? void 0 : _a.config)) {
-      throw new MicrofrontendError(
-        `vercel.json file missing required field "microFrontends.config"`,
-        {
-          type: "vercelJson",
-          subtype: "missing_field_microFrontend_config_path",
-          source: "@vercel/microfrontends/next"
-        }
-      );
-    }
-    return { configPath: vercelJson.microFrontends.config };
-  } catch (err) {
-    throw MicrofrontendError.handle(err, {
-      fileName: "vercel.json"
-    });
-  }
-}
 function getApplicationContext(opts) {
   if (opts == null ? void 0 : opts.appName) {
     return { name: opts.appName };
   }
   try {
-    const packageJsonString = fs3.readFileSync("./package.json", "utf-8");
+    const packageJsonString = fs6.readFileSync("./package.json", "utf-8");
     const packageJson = JSON.parse(packageJsonString);
     if (!packageJson.name) {
       throw new MicrofrontendError(
@@ -1725,13 +2043,15 @@ function withMicrofrontends(nextConfig, opts) {
   if (opts == null ? void 0 : opts.debug) {
     process.env.MFE_DEBUG = "true";
   }
-  const { name } = getApplicationContext(opts);
-  const { configPath } = getConfigPath(opts);
-  const mfConfig = MicrofrontendConfig.fromFile({
-    filePath: configPath
+  const { name: fromApp } = getApplicationContext(opts);
+  const microfrontends = MicrofrontendsServer.infer({
+    filePath: opts == null ? void 0 : opts.configPath,
+    meta: {
+      fromApp
+    }
   });
-  const zone = mfConfig.getZone(name);
-  setEnvironment({ zone, config: mfConfig });
+  const app = microfrontends.config.getApplication(fromApp);
+  setEnvironment({ app, microfrontends });
   let next = { ...nextConfig };
   for (const [key, transform7] of typedEntries(transforms)) {
     if ((_a = opts == null ? void 0 : opts.skipTransforms) == null ? void 0 : _a.includes(key)) {
@@ -1740,9 +2060,9 @@ function withMicrofrontends(nextConfig, opts) {
     }
     try {
       const transformedConfig = transform7({
-        zone,
+        app,
         next,
-        microfrontend: mfConfig,
+        microfrontend: microfrontends.config,
         opts: {
           isProduction: isProduction(opts)
         }
@@ -1752,9 +2072,9 @@ function withMicrofrontends(nextConfig, opts) {
       console.error("Error transforming next config", e);
     }
   }
-  displayLocalProxyInfo(mfConfig.getLocalProxyPort());
+  displayLocalProxyInfo(microfrontends.config.getLocalProxyPort());
   if (isVercel()) {
-    mfConfig.write(zone.name, { versions: ["v1", "v2"] });
+    microfrontends.writeConfig();
   }
   return next;
 }