@vercel/microfrontends 0.13.0 → 0.15.0

package/dist/next/middleware.js

@@ -1,8 +1,8 @@
 // src/next/middleware/middleware.ts
 import { NextResponse } from "next/server";
-import { pathToRegexp } from "path-to-regexp";
+import { pathToRegexp as pathToRegexp3 } from "path-to-regexp";
 
-// src/config/edge/microfrontend-config.ts
+// src/config/microfrontends-config/isomorphic/index.ts
 import { parse } from "jsonc-parser";
 
 // src/config/errors.ts
@@ -97,131 +97,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((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(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, (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;
     }
+    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,
@@ -247,176 +415,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
@@ -431,55 +657,147 @@ 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 {
-      config: {
-        name: this.name,
-        version: this.version,
-        applications,
-        options: this.options,
-        $schema: this.$schema
-      },
-      overrides: (_a = this.overrides) == null ? void 0 : _a.serialize()
-    };
+    return this.serialized;
   }
-  write(_) {
-    throw new MicrofrontendError(
-      `Writing to file to disk requires using an instance of "MicrofrontendConfig".`,
-      { type: "config", subtype: "unsupported_operation" }
-    );
+};
+
+// 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/edge/microfrontend-config.ts
-var MicrofrontendConfigEdge = class extends MicrofrontendConfigCommon {
+// 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
+        });
+      }
+    }
+    if (!defaultApplication) {
+      throw new MicrofrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    this.defaultApplication = defaultApplication;
+  }
+};
+
+// src/config/microfrontends/isomorphic/index.ts
+var Microfrontends = class {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    if (isMainConfig(config)) {
+      this.config = new MicrofrontendMainConfig({ config, overrides, meta });
+    } else {
+      this.config = new MicrofrontendChildConfig({ config, overrides, meta });
+    }
+  }
+  isChildConfig() {
+    return this.config instanceof MicrofrontendChildConfig;
+  }
   static fromEnv({
-    cookies
+    cookies,
+    meta
   }) {
-    return new MicrofrontendConfigCommon({
-      config: parse(MicrofrontendConfigCommon.getConfigFromEnv()),
-      overrides: Overrides.parseOverrides(cookies)
+    const config = MicrofrontendConfigIsomorphic.fromEnv({
+      cookies,
+      meta
     });
+    return new Microfrontends(config.serialize());
   }
 };
 
+// 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");
+  }
+  if (!((_a = app.vercel) == null ? void 0 : _a.projectId)) {
+    throw new Error(`Missing applications[${app.name}].vercel.projectId`);
+  }
+  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}"`
+    );
+  }
+  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/routing/get-domain-for-current-environment.ts
 function debugDomains(zone, env, domain) {
   if (process.env.MFE_DEBUG === "true") {
@@ -493,34 +811,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 isProduction = process.env.VERCEL_ENV === "production";
+  if (isDevelopment) {
+    return { group: "development" };
+  } else if (isProduction) {
+    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/middleware/middleware.ts
@@ -543,197 +872,188 @@ async function verifyPreviewDomain(req, rewriteDomain) {
   const vercelError = previewResponse.headers.get("x-vercel-error");
   return !(previewResponse.status === 404 && (vercelError === "DEPLOYMENT_NOT_FOUND" || vercelError === "NOT_FOUND"));
 }
-function microfrontendInternalRoutingHandler({
-  config
-}) {
-  return async (req) => {
-    const payload = Object.fromEntries(
-      await Promise.all(
-        config.getAllApplications().map(async (application) => {
-          let rewriteDomain = getDomainForCurrentEnvironment(application, {
-            ignoreOverride: true
-          });
-          const isPreviewDomainAvailable = await verifyPreviewDomain(
-            req,
-            rewriteDomain
-          );
-          if (!isPreviewDomainAvailable) {
-            rewriteDomain = application.production.toString();
-          }
-          const url = new URL(rewriteDomain);
-          return [application.name, { routing: { host: url.host } }];
-        })
-      )
-    );
-    return NextResponse.json(payload);
-  };
-}
 function getHandler({
+  config,
   application,
   flagFn,
-  pattern
+  pattern,
+  production
 }) {
   return async (req) => {
-    var _a, _b, _c;
-    const pathname = req.nextUrl.pathname;
-    const search = req.nextUrl.search;
-    const proxyRouting = req.headers.get("X-Vercel-Mfe-Proxy") === "1";
-    let rewriteDomain = proxyRouting ? null : getDomainForCurrentEnvironment(application);
-    const patchedHeaders = new Headers(req.headers);
-    const responseCallbacks = [];
-    const onRewrite = (response) => {
-      for (const callback of responseCallbacks) {
-        callback(response);
-      }
-      return response;
-    };
-    if (process.env.VERCEL_ENV === "preview" && rewriteDomain) {
-      const zoneFallbackCookieName = `__zone_${application.name}_production_fallback`;
-      const assetPrefix = (_a = application.routing) == null ? void 0 : _a.assetPrefix;
-      if (assetPrefix && pathname.startsWith(`/${assetPrefix}`) && ((_b = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _b.value) === "1") {
-        rewriteDomain = application.production.toString();
-      } else {
-        try {
-          let deploymentFound;
-          if (req.headers.get("x-vercel-skip-deployment-existence-check")) {
-            deploymentFound = true;
-          } else {
-            deploymentFound = await verifyPreviewDomain(req, rewriteDomain);
-          }
-          if (!deploymentFound) {
-            rewriteDomain = application.production.toString();
-            responseCallbacks.push((response) => {
-              response.cookies.set(zoneFallbackCookieName, "1", {
-                httpOnly: true,
-                sameSite: "lax",
-                secure: true,
-                maxAge: 60
-                // 1 minute
+    var _a, _b;
+    try {
+      const pathname = req.nextUrl.pathname;
+      const search = req.nextUrl.search;
+      const proxyRouting = req.headers.get("X-Vercel-Mfe-Proxy") === "1";
+      let rewriteDomain = proxyRouting ? null : getDomainForCurrentEnvironment(config, application.name);
+      const patchedHeaders = new Headers(req.headers);
+      const responseCallbacks = [];
+      const onRewrite = (response) => {
+        for (const callback of responseCallbacks) {
+          callback(response);
+        }
+        return response;
+      };
+      if (process.env.VERCEL_ENV === "preview" && rewriteDomain) {
+        const zoneFallbackCookieName = `__zone_${application.name}_production_fallback`;
+        const assetPrefix = application.getAssetPrefix();
+        if (assetPrefix && pathname.startsWith(`/${assetPrefix}`) && ((_a = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _a.value) === "1") {
+          rewriteDomain = production.toString();
+        } else {
+          try {
+            let deploymentFound;
+            if (req.headers.get("x-vercel-skip-deployment-existence-check")) {
+              deploymentFound = true;
+            } else {
+              deploymentFound = await verifyPreviewDomain(req, rewriteDomain);
+            }
+            if (!deploymentFound) {
+              rewriteDomain = production.toString();
+              responseCallbacks.push((response) => {
+                response.cookies.set(zoneFallbackCookieName, "1", {
+                  httpOnly: true,
+                  sameSite: "lax",
+                  secure: true,
+                  maxAge: 60
+                  // 1 minute
+                });
               });
-            });
-            try {
-              const existingCookie = patchedHeaders.get("cookie");
-              if (!(existingCookie == null ? void 0 : existingCookie.includes("__vercel_toolbar"))) {
-                patchedHeaders.set(
-                  "cookie",
-                  [`__vercel_toolbar=1`, existingCookie].join("; ")
-                );
-                responseCallbacks.push((response) => {
-                  response.cookies.set("__vercel_toolbar", "1", {
-                    httpOnly: false,
-                    sameSite: "lax",
-                    secure: true,
-                    maxAge: 29030400
+              try {
+                const existingCookie = patchedHeaders.get("cookie");
+                if (!(existingCookie == null ? void 0 : existingCookie.includes("__vercel_toolbar"))) {
+                  patchedHeaders.set(
+                    "cookie",
+                    [`__vercel_toolbar=1`, existingCookie].join("; ")
+                  );
+                  responseCallbacks.push((response) => {
+                    response.cookies.set("__vercel_toolbar", "1", {
+                      httpOnly: false,
+                      sameSite: "lax",
+                      secure: true,
+                      maxAge: 29030400
+                    });
                   });
-                });
+                }
+              } catch (error) {
               }
-            } catch (error) {
-            }
-          } else if (((_c = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _c.value) === "1") {
-            responseCallbacks.push((response) => {
-              response.cookies.set(zoneFallbackCookieName, "", {
-                httpOnly: true,
-                sameSite: "lax",
-                secure: true,
-                maxAge: 0
+            } else if (((_b = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _b.value) === "1") {
+              responseCallbacks.push((response) => {
+                response.cookies.set(zoneFallbackCookieName, "", {
+                  httpOnly: true,
+                  sameSite: "lax",
+                  secure: true,
+                  maxAge: 0
+                });
               });
-            });
+            }
+          } catch {
           }
-        } catch {
         }
       }
-    }
-    const isFlagEnabled = async () => flagFn ? flagFn() : true;
-    if (pattern.test(pathname) && await isFlagEnabled()) {
-      if (proxyRouting) {
-        const headers = new Headers(req.headers);
-        headers.set("x-vercel-mfe-zone", application.name);
+      const isFlagEnabled = async () => flagFn ? flagFn() : true;
+      if (pattern.test(pathname) && await isFlagEnabled()) {
+        if (proxyRouting) {
+          const headers = new Headers(req.headers);
+          headers.set("x-vercel-mfe-zone", application.name);
+          return onRewrite(
+            NextResponse.next({
+              request: {
+                headers
+              },
+              headers: {
+                // temporary, can delete when proxyRouting flag is removed
+                "x-vercel-mfe-middleware-sent-proxy": application.name
+              }
+            })
+          );
+        }
         return onRewrite(
-          NextResponse.next({
+          NextResponse.rewrite(`${rewriteDomain}${pathname}${search}`, {
             request: {
-              headers
-            },
-            headers: {
-              // temporary, can delete when proxyRouting flag is removed
-              "x-vercel-mfe-middleware-sent-proxy": application.name
+              headers: patchedHeaders
             }
           })
         );
       }
-      return onRewrite(
-        NextResponse.rewrite(`${rewriteDomain}${pathname}${search}`, {
-          request: {
-            headers: patchedHeaders
-          }
-        })
-      );
+    } catch (e) {
+      console.error("An error occured in the microfrontends middleware:", e);
+      throw e;
     }
   };
 }
 function getMicrofrontendsMiddleware({
   request,
-  flagValues
+  flagValues,
+  fromApp
 }) {
-  var _a, _b;
-  const config = MicrofrontendConfigEdge.fromEnv({
-    cookies: request.cookies.getAll()
+  const microfrontends = Microfrontends.fromEnv({
+    cookies: request.cookies.getAll(),
+    meta: {
+      fromApp
+    }
   });
   const middlewares = [];
-  middlewares.push({
-    src: "/.well-known/vercel/microfrontend-routing",
-    fn: microfrontendInternalRoutingHandler({ config })
-  });
-  for (const application of config.getAllApplications()) {
+  if (microfrontends.config instanceof MicrofrontendChildConfig) {
+    return middlewares;
+  }
+  const config = microfrontends.config;
+  const production = config.defaultApplication.production;
+  for (const application of config.getChildApplications()) {
     if (application.name === process.env.NEXT_PUBLIC_MFE_CURRENT_APPLICATION) {
       continue;
     }
-    if (application.routing) {
-      if (process.env.VERCEL_ENV === "preview" && application.routing.assetPrefix) {
-        const pattern = pathToRegexp(
-          `/${application.routing.assetPrefix}/:path+`
-        );
-        middlewares.push({
-          src: pattern,
-          fn: getHandler({
-            application,
-            pattern
-          })
-        });
-      }
-      for (const pathGroup of application.routing.matches) {
-        if (process.env.VERCEL_ENV === "preview" || ((_a = pathGroup.options) == null ? void 0 : _a.flag)) {
-          const flagName = (_b = pathGroup.options) == null ? void 0 : _b.flag;
-          let flagFn;
-          if (flagName) {
-            flagFn = flagValues == null ? void 0 : flagValues[flagName];
-            if (!flagFn) {
-              throw new Error(
-                `Flag "${flagName}" was specified to control routing for path group "${pathGroup.group}" in application ${application.name} but not found in provided flag values.`
-              );
-            }
-          }
-          for (const path of pathGroup.paths) {
-            const pattern = pathToRegexp(path);
-            middlewares.push({
-              src: pattern,
-              fn: getHandler({
-                application,
-                flagFn,
-                pattern
-              })
-            });
+    if (process.env.VERCEL_ENV === "preview") {
+      const pattern = pathToRegexp3(`/${application.getAssetPrefix()}/:path+`);
+      middlewares.push({
+        src: pattern,
+        fn: getHandler({
+          config,
+          application,
+          pattern,
+          production
+        })
+      });
+    }
+    for (const pathGroup of application.routing) {
+      if (process.env.VERCEL_ENV === "preview" || pathGroup.flag) {
+        const flagName = pathGroup.flag;
+        let flagFn;
+        if (flagName) {
+          flagFn = flagValues == null ? void 0 : flagValues[flagName];
+          if (!flagFn) {
+            throw new Error(
+              `Flag "${flagName}" was specified to control routing for path group "${pathGroup.group}" in application ${application.name} but not found in provided flag values.`
+            );
           }
         }
+        for (const path of pathGroup.paths) {
+          const pattern = pathToRegexp3(path);
+          middlewares.push({
+            src: pattern,
+            fn: getHandler({
+              config,
+              application,
+              flagFn,
+              pattern,
+              production
+            })
+          });
+        }
       }
     }
   }
   return middlewares;
 }
-async function runMicrofrontendsMiddleware(request, flagValues) {
+async function runMicrofrontendsMiddleware({
+  request,
+  fromApp,
+  flagValues
+}) {
   const pathname = request.nextUrl.pathname;
   const middlewares = getMicrofrontendsMiddleware({
     request,
-    flagValues
+    flagValues,
+    fromApp
   });
   for (const mware of middlewares) {
     if (typeof mware.src === "string" ? pathname === mware.src : mware.src.test(pathname)) {