@vercel/microfrontends 0.14.0 → 0.15.0

package/dist/next/testing.js

@@ -9,35 +9,8 @@ import { matchHas } from "next/dist/shared/lib/router/utils/prepare-destination"
 import { NextRequestHint } from "next/dist/server/web/adapter";
 import { WebNextRequest } from "next/dist/server/base-http/web";
 
-// src/config/types.ts
-var isDefaultApplicationConfig = (app) => app.default && typeof app.routing === "undefined";
-
-// src/config/microfrontend-config.ts
-import fs2 from "node:fs";
-
-// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
-import path from "node:path";
-
-// src/config-v2/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-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/microfrontends-config/isomorphic/index.ts
+import { parse } from "jsonc-parser";
 
 // src/config/errors.ts
 var MicrofrontendError = class extends Error {
@@ -131,131 +104,299 @@ 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/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((match2) => !match2.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(path) {
+    if (!path.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path]) {
+      return this.pathCache[path];
+    }
+    const pathname = new URL(path, "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[path] = 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, (match2) => {
-        if (match2 === options.joinString)
-          return match2;
-        return "";
-      });
-      if (tag.length > options.maxLen)
-        tag = tag.substring(0, options.maxLen);
-      tag = tag.replace(reJoinString, options.joinString);
-      return tag;
     }
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path] = defaultApplication[0];
+    return defaultApplication[0];
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
+
+// src/config/overrides/is-override-cookie.ts
+function isOverrideCookie(cookie) {
+  var _a;
+  return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+}
+
+// src/config/overrides/get-override-from-cookie.ts
+function getOverrideFromCookie(cookie) {
+  if (!isOverrideCookie(cookie) || !cookie.value)
+    return;
+  return {
+    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
+    host: cookie.value
   };
 }
-var urlSafeString = buildUrlSafeString().generate;
-function makeUrlSafe(name) {
-  return urlSafeString(name.replace(/\//g, "-")).replace(/^-*/g, "").replace(/-*$/g, "");
+
+// 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/overrides/config.ts
-var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
-var _Overrides = class {
-  constructor(config) {
-    this.config = config;
-  }
-  static getAppEnvOverrideCookieName(zone) {
-    return `${_Overrides.overrideEnvCookiePrefix}${zone}`;
+// 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 isOverrideCookie(cookie) {
-    var _a;
-    return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+};
+var validateConfigPaths = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
   }
-  static getOverrideFromCookie(cookie) {
-    if (!_Overrides.isOverrideCookie(cookie) || !cookie.value)
-      return;
-    return {
-      zone: cookie.name.replace(_Overrides.overrideEnvCookiePrefix, ""),
-      host: cookie.value
-    };
+  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 path of pathMatch.paths) {
+        const tokens = parsePathRegexp(path);
+        for (const token of tokens.slice(0, -1)) {
+          if (typeof token !== "string") {
+            errors.push(
+              `Path ${path} may only have a :wildcard in the last path component`
+            );
+          }
+        }
+        const existing = pathsByApplicationId.get(path);
+        if (existing) {
+          existing.applications.push(id);
+        } else {
+          pathsByApplicationId.set(path, {
+            applications: [id],
+            matcher: pathToRegexp2(path),
+            applicationId: id
+          });
+        }
+      }
+    }
   }
-  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 entries = Array.from(pathsByApplicationId.entries());
+  entries.forEach(([path, { applications: ids, matcher, applicationId }]) => {
+    if (ids.length > 1) {
+      errors.push(
+        `Duplicate path "${path}" for applications "${ids.join(", ")}"`
+      );
+    }
+    entries.forEach(
+      ([
+        matchPath,
+        { applications: matchIds, applicationId: matchApplicationId }
+      ]) => {
+        if (path === matchPath) {
+          return;
+        }
+        if (applicationId === matchApplicationId) {
+          return;
+        }
+        if (matcher.test(matchPath)) {
+          const source = `"${path}" 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];
-    }
-    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];
+};
+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,
@@ -281,176 +422,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;
   }
+  getApplicationsByType() {
+    return {
+      defaultApplication: this.defaultApplication,
+      applications: Object.values(this.childApplications)
+    };
+  }
+  getChildApplications() {
+    return Object.values(this.childApplications);
+  }
   getAllApplications() {
-    return Object.values(this.zones);
+    return [
+      this.defaultApplication,
+      ...Object.values(this.childApplications)
+    ].filter(Boolean);
   }
-  getZone(name) {
-    const zone = this.zones[name];
-    if (!zone) {
+  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
@@ -465,764 +664,144 @@ 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 {
-      $schema: this.$schema,
-      name: this.name,
-      version: this.version,
-      options: this.options,
-      applications
-    };
-  }
-  serialize() {
-    var _a;
-    const applications = {};
-    for (const [name, zone] of Object.entries(this.zones)) {
-      applications[name] = zone.serialize();
-    }
-    return {
-      config: {
-        name: this.name,
-        version: this.version,
-        applications,
-        options: this.options,
-        $schema: this.$schema
-      },
-      overrides: (_a = this.overrides) == null ? void 0 : _a.serialize()
-    };
-  }
-  write(_) {
-    throw new MicrofrontendError(
-      `Writing to file to disk requires using an instance of "MicrofrontendConfig".`,
-      { type: "config", subtype: "unsupported_operation" }
-    );
-  }
-};
-
-// src/config/utils/get-output-file-path.ts
-import path2 from "node:path";
-
-// src/config/constants.ts
-var MFE_CONFIG_DEFAULT_FILE_PATH2 = "micro-frontends";
-var MFE_CONFIG_DEFAULT_FILE_NAME2 = "micro-frontends.config.json";
-
-// src/config/utils/get-output-file-path.ts
-function getOutputFilePath2() {
-  if (isVercel()) {
-    return path2.join(
-      ".vercel",
-      MFE_CONFIG_DEFAULT_FILE_PATH2,
-      MFE_CONFIG_DEFAULT_FILE_NAME2
-    );
+    return this.serialized.config;
   }
-  return path2.join(MFE_CONFIG_DEFAULT_FILE_PATH2, MFE_CONFIG_DEFAULT_FILE_NAME2);
-}
-
-// src/config/validation.ts
-import { parse } from "jsonc-parser";
-import { pathToRegexp, parse as parsePathRegexp } from "path-to-regexp";
-import { Ajv } from "ajv";
-
-// schema/schema.json
-var schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $ref: "#/definitions/Config",
-  definitions: {
-    Config: {
-      type: "object",
-      properties: {
-        version: {
-          type: "string"
-        },
-        $schema: {
-          type: "string"
-        },
-        name: {
-          type: "string",
-          description: 'Name for the micro-frontend site (eg. "vercel.com", "vercel-site" etc.).'
-        },
-        applications: {
-          $ref: "#/definitions/ApplicationConfigsById"
-        },
-        options: {
-          $ref: "#/definitions/Options",
-          description: "Optional configuration for the entire micro-frontends setup."
-        }
-      },
-      required: ["version", "applications"],
-      description: "Configuration for micro-frontend applications\n\nTODO: Add proxy configuration"
-    },
-    ApplicationConfigsById: {
-      type: "object",
-      additionalProperties: {
-        $ref: "#/definitions/ApplicationConfig"
-      }
-    },
-    ApplicationConfig: {
-      anyOf: [
-        {
-          $ref: "#/definitions/DefaultApplicationConfig"
-        },
+  toClientConfig() {
+    const applications = Object.fromEntries(
+      Object.entries(this.childApplications).map(([name, application]) => [
+        name,
         {
-          $ref: "#/definitions/CommonApplicationConfig"
-        }
-      ],
-      description: "A Micro-Frontend Deployment Target"
-    },
-    DefaultApplicationConfig: {
-      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"
-        },
-        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"]
-        },
-        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: {
-      type: "object",
-      properties: {
-        assetPrefix: {
-          type: "string",
-          description: "[assetPrefix] for the application"
-        },
-        matches: {
-          type: "array",
-          items: {
-            $ref: "#/definitions/PathGroup"
-          },
-          description: "Path expressions that are routed to this application."
-        }
-      },
-      required: ["matches"]
-    },
-    PathGroup: {
-      type: "object",
-      properties: {
-        group: {
-          type: "string",
-          description: "Optional group name for the paths"
-        },
-        options: {
-          type: "object",
-          properties: {
-            flag: {
-              type: "string",
-              description: "flag name that can be used to enable/disable all paths in the group"
-            }
-          }
-        },
-        paths: {
-          type: "array",
-          items: {
-            type: "string"
-          }
+          default: false,
+          routing: application.routing
         }
-      },
-      required: ["paths"]
-    },
-    HostConfig: {
-      type: "object",
-      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`)."
-        },
-        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"
-        }
-      },
-      required: ["host"]
-    },
-    Vercel: {
-      type: "object",
-      properties: {
-        projectId: {
-          type: "string",
-          description: "Vercel project ID"
-        },
-        projectName: {
-          type: "string",
-          description: "Vercel project name (temporary until we can use project ID)"
-        },
-        defaultRoute: {
-          type: "string",
-          description: "The default route for the application. Used to render screenshots, favicons, and provide direct zone links"
-        },
-        routeSpeedInsightsToDefaultZone: {
-          type: "boolean",
-          description: "Whether to route Speed Insights to the default zone or each individual microfrontend."
-        }
-      },
-      required: ["projectId"]
-    },
-    CommonApplicationConfig: {
-      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"
-        },
-        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"]
-        },
-        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."
-        }
-      }
-    },
-    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((match2) => match2.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((match2) => match2.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(", ")}"`
-      );
+    if (this.defaultApplication) {
+      applications[this.defaultApplication.name] = {
+        default: true
+      };
     }
-    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"
+    return new MicrofrontendConfigClient({
+      applications
     });
   }
-};
-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`;
-      }
-      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`;
-      }
-    }
-  }
-  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" }
-      );
-    }
+  serialize() {
+    return this.serialized;
   }
 };
 
-// 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;
-  }
-  return {
-    ...common,
-    routing: convertV1RoutingToV2Routing(application.routing)
-  };
-}
-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)
-        ])
-      )
-    };
-  }
-  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/routing/get-domain-from-environment.ts
+function getDomainFromEnvironment({
+  app,
+  target
+}) {
+  var _a;
+  const mfeProjects = JSON.parse(
+    process.env.VERCEL_MICROFRONTENDS_PROJECTS ?? "[]"
   );
-}
-
-// 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;
+  if (mfeProjects.length === 0) {
+    throw new Error("Missing related microfrontends project information");
   }
-  static fromEnv({
-    cookies
-  }) {
-    return new MicrofrontendConfigCommon({
-      config: MicrofrontendConfig.validate(
-        MicrofrontendConfigCommon.getConfigFromEnv()
-      ),
-      overrides: Overrides.parseOverrides(cookies)
-    });
+  if (!((_a = app.vercel) == null ? void 0 : _a.projectId)) {
+    throw new Error(`Missing applications[${app.name}].vercel.projectId`);
   }
-  static fromFile({
-    filePath
-  }) {
-    try {
-      const config = fs2.readFileSync(filePath, "utf-8");
-      return new MicrofrontendConfig({
-        config: MicrofrontendConfig.validate(config)
-      });
-    } catch (e) {
-      throw MicrofrontendError.handle(e, {
-        fileName: filePath
-      });
+  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 related microfrontends project information for application "${app.name}"`
+    );
   }
-  /**
-   * Writes the configuration to 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);
-    }
+  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 domain.startsWith("https://") ? domain : `https://${domain}`;
+}
 
 // src/next/testing/index.ts
-function expandWildcards(path3) {
-  if (path3.includes("/:path*") || path3.includes("/:slug*")) {
+function expandWildcards(path) {
+  if (path.includes("/:path*") || path.includes("/:slug*")) {
     return [
-      path3 === "/:path*" || path3 === "/:slug*" ? "/" : path3.replace("/:path*", "").replace("/:slug*", ""),
-      path3.replace("/:path*", "/foo").replace("/:slug*", "/foo"),
-      path3.replace("/:path*", "/foo/bar").replace("/:slug*", "/foo/bar")
+      path === "/:path*" || path === "/:slug*" ? "/" : path.replace("/:path*", "").replace("/:slug*", ""),
+      path.replace("/:path*", "/foo").replace("/:slug*", "/foo"),
+      path.replace("/:path*", "/foo/bar").replace("/:slug*", "/foo/bar")
     ];
   }
-  if (path3.includes("/:path+") || path3.includes("/:slug+")) {
+  if (path.includes("/:path+") || path.includes("/:slug+")) {
     return [
-      path3.replace("/:path+", "/foo").replace("/:slug+", "/foo"),
-      path3.replace("/:path+", "/foo/bar").replace("/:slug+", "/foo/bar")
+      path.replace("/:path+", "/foo").replace("/:slug+", "/foo"),
+      path.replace("/:path+", "/foo/bar").replace("/:slug+", "/foo/bar")
     ];
   }
-  if (path3.includes("/:path") || path3.includes("/:slug")) {
-    return [path3.replace("/:path", "/foo").replace("/:slug", "/foo")];
+  if (path.includes("/:path") || path.includes("/:slug")) {
+    return [path.replace("/:path", "/foo").replace("/:slug", "/foo")];
   }
-  return [path3];
+  return [path];
 }
-function loadMicrofrontendConfigForEdge(path3) {
-  const rawMfConfig = parse2(readFileSync(path3, "utf-8"));
-  return new MicrofrontendConfig({ config: rawMfConfig });
+function loadMicrofrontendConfigForEdge(path) {
+  const rawMfConfig = parse2(readFileSync(path, "utf-8"));
+  return new MicrofrontendConfigIsomorphic({
+    config: rawMfConfig,
+    meta: { fromApp: "test" }
+  });
 }
-function getAllZoneNames(mfConfig) {
-  return mfConfig.getAllApplications().filter((app) => !app.default).map((app) => app.name);
+function getAllChildApplicationNames(mfConfig) {
+  return mfConfig.getChildApplications().map((app) => app.name);
 }
-function getLaunchedPathsForZone(mfConfig, zoneName) {
-  var _a, _b;
-  const zone = mfConfig.getZone(zoneName);
+function getLaunchedPathsForApp(mfConfig, appName) {
+  const app = mfConfig.getApplication(appName);
+  if (app instanceof DefaultApplication) {
+    return [];
+  }
   return [
-    ...((_a = zone.routing) == null ? void 0 : _a.assetPrefix) ? [`/${zone.routing.assetPrefix}/_next/static`] : [],
-    ...((_b = zone.routing) == null ? void 0 : _b.matches.filter((group) => {
-      var _a2;
-      return !((_a2 = group.options) == null ? void 0 : _a2.flag);
-    }).flatMap((group) => group.paths.flatMap(expandWildcards))) ?? []
+    `/${app.getAssetPrefix()}/_next/static`,
+    ...app.routing.filter((group) => !group.flag).flatMap((group) => group.paths.flatMap(expandWildcards))
   ];
 }
-function getFlaggedPathsForZone(mfConfig, zoneName) {
-  var _a;
-  const zone = mfConfig.getZone(zoneName);
-  return ((_a = zone.routing) == null ? void 0 : _a.matches.filter((group) => {
-    var _a2;
-    return Boolean((_a2 = group.options) == null ? void 0 : _a2.flag);
-  }).flatMap((group) => group.paths.flatMap(expandWildcards))) ?? [];
+function getFlaggedPathsForApp(mfConfig, appName) {
+  const app = mfConfig.getApplication(appName);
+  if (app instanceof DefaultApplication) {
+    return [];
+  }
+  return app.routing.filter((group) => Boolean(group.flag)).flatMap((group) => group.paths.flatMap(expandWildcards));
 }
-function getExpectedDomainForZone(mfConfig, zoneName, env) {
-  const zone = mfConfig.getZone(zoneName);
-  return env === "development" ? zone.development.local.toString() : zone.production.toString();
+function getExpectedDomainForApp(mfConfig, appName, env) {
+  const app = mfConfig.getApplication(appName);
+  const defaultApp = mfConfig.getDefaultApplication();
+  if (env === "development") {
+    return app.development.local.toString();
+  }
+  if (["preview", "production"].includes(env)) {
+    const target = env;
+    return getDomainFromEnvironment({ app, target });
+  }
+  return defaultApp.production.toString();
 }
 function getAllMultiZonesPaths(mfConfig) {
-  return mfConfig.getAllApplications().flatMap((app) => {
-    var _a;
-    return ((_a = app.routing) == null ? void 0 : _a.matches.flatMap(
-      (group) => group.paths.flatMap(expandWildcards)
-    )) ?? [];
+  return mfConfig.getChildApplications().flatMap((app) => {
+    return app.routing.flatMap((group) => group.paths.flatMap(expandWildcards));
   });
 }
-function urlMatches(middlewareConfig, path3, host) {
+function urlMatches(middlewareConfig, path, host) {
   if (!middlewareConfig.matcher) {
     return false;
   }
   const matchers = Array.isArray(middlewareConfig.matcher) ? middlewareConfig.matcher : [middlewareConfig.matcher];
   for (let matcher of matchers) {
     matcher = typeof matcher === "string" ? { source: matcher } : matcher;
-    if (match(matcher.source)(path3)) {
+    if (match(matcher.source)(path)) {
       if (matchHas(
         new WebNextRequest(
           new NextRequestHint({
             init: { headers: { host } },
-            input: `https://${host}${path3}`,
+            input: `https://${host}${path}`,
             page: "unused_placeholder"
           })
         ),
@@ -1237,54 +816,50 @@ function urlMatches(middlewareConfig, path3, host) {
   return false;
 }
 function validateMiddlewareConfig(middlewareConfig, microfrontendConfigOrPath, extraProductionMatches) {
-  var _a, _b;
   const microfrontendConfig = typeof microfrontendConfigOrPath === "string" ? loadMicrofrontendConfigForEdge(microfrontendConfigOrPath) : microfrontendConfigOrPath;
   const errors = [];
   const usedExtraProductionMatches = /* @__PURE__ */ new Set();
-  for (const application of microfrontendConfig.getAllApplications()) {
-    if ((_a = application.routing) == null ? void 0 : _a.matches) {
-      const matches = [...application.routing.matches];
-      if (application.routing.assetPrefix) {
-        matches.push({
-          paths: [`/${application.routing.assetPrefix}/_next/:path+`]
-        });
-      }
-      for (const aMatch of matches) {
-        const isFlagged = Boolean((_b = aMatch.options) == null ? void 0 : _b.flag);
-        for (const path3 of aMatch.paths) {
-          const pathsToTest = expandWildcards(path3);
-          for (const testPath of pathsToTest) {
-            const pathForDisplay = `${testPath}${path3 === testPath ? "" : ` (synthesized from ${path3})`}`;
-            if (!urlMatches(middlewareConfig, testPath, "test.nonproduction.host")) {
+  for (const application of microfrontendConfig.getChildApplications()) {
+    const matches = [...application.routing];
+    matches.push({
+      paths: [`/${application.getAssetPrefix()}/_next/:path+`]
+    });
+    for (const aMatch of matches) {
+      const isFlagged = Boolean(aMatch.flag);
+      for (const path of aMatch.paths) {
+        const pathsToTest = expandWildcards(path);
+        for (const testPath of pathsToTest) {
+          const productionHost = microfrontendConfig.getDefaultApplication().production.host;
+          const pathForDisplay = `${testPath}${path === testPath ? "" : ` (synthesized from ${path})`}`;
+          if (!urlMatches(middlewareConfig, testPath, "test.nonproduction.host")) {
+            errors.push(
+              `Matcher misconfigured for ${pathForDisplay}. This path should have matched the middleware config on a non-production host, but did not. Microfrontends require a middleware config matcher that matches on this host everywhere but in production. That can be configured with a configuration like this:
+${getSampleMatcher(path, productionHost)}`
+            );
+            break;
+          }
+          const productionUrlMatches = urlMatches(
+            middlewareConfig,
+            testPath,
+            productionHost
+          );
+          if (isFlagged) {
+            if (!productionUrlMatches) {
               errors.push(
-                `Matcher misconfigured for ${pathForDisplay}. This path should have matched the middleware config on a non-production host, but did not. Microfrontends require a middleware config matcher that matches on this host everywhere but in production. That can be configured with a configuration like this:
-${getSampleMatcher(path3, microfrontendConfig.getDefaultZone().production.host)}`
+                `Matcher misconfigured for ${pathForDisplay}. Middleware config matchers for flagged paths should ALWAYS match.`
               );
               break;
             }
-            const productionUrlMatches = urlMatches(
-              middlewareConfig,
-              testPath,
-              microfrontendConfig.getDefaultZone().production.host
-            );
-            if (isFlagged) {
-              if (!productionUrlMatches) {
-                errors.push(
-                  `Matcher misconfigured for ${pathForDisplay}. Middleware config matchers for flagged paths should ALWAYS match.`
-                );
-                break;
-              }
-            } else if (productionUrlMatches) {
-              if (extraProductionMatches == null ? void 0 : extraProductionMatches.includes(path3)) {
-                usedExtraProductionMatches.add(path3);
-              } else {
-                errors.push(
-                  `Matcher misconfigured for ${pathForDisplay}. This path matched the middleware config on a production host, but should not have. Microfrontends require a middleware config matcher that matches on this host everywhere but in production. If this is desired, you can add the path the to extraProductionMatches parameter. Otherwise, you can set up a configuration like this:
-${getSampleMatcher(path3, microfrontendConfig.getDefaultZone().production.host)}`
-                );
-              }
-              break;
+          } else if (productionUrlMatches) {
+            if (extraProductionMatches == null ? void 0 : extraProductionMatches.includes(path)) {
+              usedExtraProductionMatches.add(path);
+            } else {
+              errors.push(
+                `Matcher misconfigured for ${pathForDisplay}. This path matched the middleware config on a production host, but should not have. Microfrontends require a middleware config matcher that matches on this host everywhere but in production. If this is desired, you can add the path the to extraProductionMatches parameter. Otherwise, you can set up a configuration like this:
+${getSampleMatcher(path, productionHost)}`
+              );
             }
+            break;
           }
         }
       }
@@ -1305,9 +880,9 @@ ${getSampleMatcher(path3, microfrontendConfig.getDefaultZone().production.host)}
     throw new Error(message + errors.join("\n\n- "));
   }
 }
-function getSampleMatcher(path3, host) {
+function getSampleMatcher(path, host) {
   return `  {
-    source: '${path3}', // This can also be a broader regular expression.
+    source: '${path}', // This can also be a broader regular expression.
     missing: [
       type: 'header',
       key: 'host',
@@ -1320,21 +895,25 @@ async function validateMiddlewareOnFlaggedPaths(microfrontendConfigOrPath, middl
   const initialMfePreviewDomains = process.env.MFE_PREVIEW_DOMAINS;
   try {
     const microfrontendConfig = typeof microfrontendConfigOrPath === "string" ? loadMicrofrontendConfigForEdge(microfrontendConfigOrPath) : microfrontendConfigOrPath;
-    const fakePreviewDomains = createFakePreviewDomains(microfrontendConfig);
-    process.env.MFE_PREVIEW_DOMAINS = JSON.stringify(fakePreviewDomains);
-    const allZoneNames = getAllZoneNames(microfrontendConfig);
+    const allAppNames = getAllChildApplicationNames(microfrontendConfig);
     const errors = [];
-    for (const zoneName of allZoneNames) {
-      const flaggedPaths = getFlaggedPathsForZone(
-        microfrontendConfig,
-        zoneName
-      );
+    for (const appName of allAppNames) {
+      const flaggedPaths = getFlaggedPathsForApp(microfrontendConfig, appName);
       if (flaggedPaths.length) {
         for (const env of ["preview", "production"]) {
           process.env.VERCEL_ENV = env;
-          for (const path3 of flaggedPaths) {
-            const expectedHost = env === "preview" ? fakePreviewDomains[zoneName] : getExpectedDomainForZone(microfrontendConfig, zoneName, env);
-            const requestPath = `https://${microfrontendConfig.getDefaultZone().production.host}${path3}`;
+          for (const path of flaggedPaths) {
+            const expectedHost = getExpectedDomainForApp(
+              microfrontendConfig,
+              appName,
+              env
+            );
+            const expectedDefaultHost = getExpectedDomainForApp(
+              microfrontendConfig,
+              microfrontendConfig.getDefaultApplication().name,
+              env
+            );
+            const requestPath = `${expectedDefaultHost}${path}`;
             const request = new NextRequest(requestPath, {
               headers: { "x-vercel-skip-deployment-existence-check": "1" }
             });
@@ -1342,7 +921,7 @@ async function validateMiddlewareOnFlaggedPaths(microfrontendConfigOrPath, middl
               request,
               {}
             );
-            const expectedUrl = `${expectedHost}${path3}`;
+            const expectedUrl = `${expectedHost}${path}`;
             if (!response) {
               errors.push(
                 `middleware did not action for ${requestPath} in ${env}. Expected a rewrite to ${expectedUrl}`
@@ -1368,19 +947,13 @@ async function validateMiddlewareOnFlaggedPaths(microfrontendConfigOrPath, middl
     process.env.MFE_PREVIEW_DOMAINS = initialMfePreviewDomains;
   }
 }
-function createFakePreviewDomains(config) {
-  return config.getAllApplications().reduce((result, application) => {
-    result[application.name] = `https://preview-for-middleware-test-only.${application.production.host}`;
-    return result;
-  }, {});
-}
 export {
   expandWildcards,
+  getAllChildApplicationNames,
   getAllMultiZonesPaths,
-  getAllZoneNames,
-  getExpectedDomainForZone,
-  getFlaggedPathsForZone,
-  getLaunchedPathsForZone,
+  getExpectedDomainForApp,
+  getFlaggedPathsForApp,
+  getLaunchedPathsForApp,
   loadMicrofrontendConfigForEdge,
   validateMiddlewareConfig,
   validateMiddlewareOnFlaggedPaths