@vercel/microfrontends 0.9.0 → 0.10.0

package/dist/bin/cli.cjs

@@ -29,7 +29,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "@vercel/microfrontends",
-  version: "0.9.0",
+  version: "0.10.0",
   private: false,
   description: "Defines configuration and utilities for micro-frontend development",
   repository: {
@@ -87,6 +87,10 @@ var package_default = {
       import: "./dist/v2/microfrontends.js",
       require: "./dist/v2/microfrontends.cjs"
     },
+    "./v2/overrides": {
+      import: "./dist/v2/overrides.js",
+      require: "./dist/v2/overrides.cjs"
+    },
     "./v2/microfrontends/server": {
       import: "./dist/v2/microfrontends/server.js",
       require: "./dist/v2/microfrontends/server.cjs"
@@ -129,6 +133,7 @@ var package_default = {
       "next/testing": ["./dist/next/testing.d.ts"],
       "v2/config": ["./dist/v2/config.d.ts"],
       "v2/microfrontends": ["./dist/v2/microfrontends.d.ts"],
+      "v2/overrides": ["./dist/v2/overrides.d.ts"],
       "v2/microfrontends/server": ["./dist/v2/microfrontends/server.d.ts"],
       "v2/schema": ["./dist/v2/schema.d.ts"],
       "v2/next/config": ["./dist/v2/next/config.d.ts"],
@@ -175,7 +180,7 @@ var package_default = {
     "@vercel-private/conformance": "^1.12.2-canary.0",
     jest: "^29.7.0",
     "jest-environment-jsdom": "29.2.2",
-    next: "15.0.4-canary.17",
+    next: "15.0.4-canary.26",
     react: "19.0.0-rc-380f5d67-20241113",
     "react-dom": "19.0.0-rc-380f5d67-20241113",
     "ts-json-schema-generator": "^1.1.2",
@@ -185,7 +190,7 @@ var package_default = {
     webpack: "5"
   },
   peerDependencies: {
-    next: "15.0.4-canary.17",
+    next: "15.0.4-canary.26",
     react: "19.0.0-rc-380f5d67-20241113",
     "react-dom": "19.0.0-rc-380f5d67-20241113"
   },
@@ -197,14 +202,15 @@ var package_default = {
 // src/bin/local-proxy.ts
 var http = __toESM(require("http"), 1);
 var https = __toESM(require("https"), 1);
+var import_types2 = require("util/types");
 var import_cookie = require("cookie");
-var import_path_to_regexp2 = require("path-to-regexp");
+var import_path_to_regexp4 = require("path-to-regexp");
 var import_http_proxy = __toESM(require("http-proxy"), 1);
 
 // src/config/types.ts
 var isDefaultApplicationConfig = (app) => app.default && typeof app.routing === "undefined";
 
-// src/config/micro-frontend-config.ts
+// src/config/microfrontend-config.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
 
 // src/config-v2/microfrontends/server/utils/get-output-file-path.ts
@@ -232,14 +238,14 @@ function getOutputFilePath() {
 }
 
 // src/config/errors.ts
-var MicroFrontendError = class extends Error {
+var MicrofrontendError = class extends Error {
   constructor(message, opts) {
     super(message);
-    this.name = "MicroFrontendsError";
-    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/micro-frontends";
+    this.name = "MicrofrontendsError";
+    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/microfrontends";
     this.type = (opts == null ? void 0 : opts.type) ?? "unknown";
     this.subtype = opts == null ? void 0 : opts.subtype;
-    Error.captureStackTrace(this, MicroFrontendError);
+    Error.captureStackTrace(this, MicrofrontendError);
   }
   isKnown() {
     return this.type !== "unknown";
@@ -248,13 +254,13 @@ var MicroFrontendError = class extends Error {
     return !this.isKnown();
   }
   /**
-   * Converts an error to a MicroFrontendsError.
+   * Converts an error to a MicrofrontendsError.
    * @param original - The original error to convert.
-   * @returns The converted MicroFrontendsError.
+   * @returns The converted MicrofrontendsError.
    */
   static convert(original, opts) {
     if (opts == null ? void 0 : opts.fileName) {
-      const err = MicroFrontendError.convertFSError(original, opts.fileName);
+      const err = MicrofrontendError.convertFSError(original, opts.fileName);
       if (err) {
         return err;
       }
@@ -262,25 +268,25 @@ var MicroFrontendError = class extends Error {
     if (original.message.includes(
       "Code generation from strings disallowed for this context"
     )) {
-      return new MicroFrontendError(original.message, {
+      return new MicrofrontendError(original.message, {
         type: "config",
         subtype: "unsupported_validation_env",
         source: "ajv"
       });
     }
-    return new MicroFrontendError(original.message);
+    return new MicrofrontendError(original.message);
   }
   static convertFSError(original, fileName) {
     if (original instanceof Error && "code" in original) {
       if (original.code === "ENOENT") {
-        return new MicroFrontendError(`Could not find "${fileName}"`, {
+        return new MicrofrontendError(`Could not find "${fileName}"`, {
           type: "config",
           subtype: "unable_to_read_file",
           source: "fs"
         });
       }
       if (original.code === "EACCES") {
-        return new MicroFrontendError(
+        return new MicrofrontendError(
           `Permission denied while accessing "${fileName}"`,
           {
             type: "config",
@@ -291,7 +297,7 @@ var MicroFrontendError = class extends Error {
       }
     }
     if (original instanceof SyntaxError) {
-      return new MicroFrontendError(
+      return new MicrofrontendError(
         `Failed to parse "${fileName}": Invalid JSON format.`,
         {
           type: "config",
@@ -303,23 +309,23 @@ var MicroFrontendError = class extends Error {
     return null;
   }
   /**
-   * Handles an unknown error and returns a MicroFrontendsError instance.
+   * Handles an unknown error and returns a MicrofrontendsError instance.
    * @param err - The error to handle.
-   * @returns A MicroFrontendsError instance.
+   * @returns A MicrofrontendsError instance.
    */
   static handle(err, opts) {
-    if (err instanceof MicroFrontendError) {
+    if (err instanceof MicrofrontendError) {
       return err;
     }
     if (err instanceof Error) {
-      return MicroFrontendError.convert(err, opts);
+      return MicrofrontendError.convert(err, opts);
     }
     if (typeof err === "object" && err !== null) {
       if ("message" in err && typeof err.message === "string") {
-        return MicroFrontendError.convert(new Error(err.message), opts);
+        return MicrofrontendError.convert(new Error(err.message), opts);
       }
     }
-    return new MicroFrontendError("An unknown error occurred");
+    return new MicrofrontendError("An unknown error occurred");
   }
 };
 
@@ -402,27 +408,27 @@ var _Overrides = class {
     });
     return overridesConfig;
   }
-  static validOverrideDomainsForZone(microFrontendConfig, zone) {
+  static validOverrideDomainsForZone(microfrontendConfig, zone) {
     var _a, _b, _c, _d, _e;
-    const projectName = (_a = microFrontendConfig.getZone(zone).vercel) == null ? void 0 : _a.projectName;
+    const projectName = (_a = microfrontendConfig.getZone(zone).vercel) == null ? void 0 : _a.projectName;
     if (!projectName) {
-      return [microFrontendConfig.getZone(zone).production.host];
+      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;
+    const previewDeploymentSuffix = (_c = (_b = microfrontendConfig.options) == null ? void 0 : _b.vercel) == null ? void 0 : _c.previewDeploymentSuffix;
+    const teamSlug = (_e = (_d = microfrontendConfig.options) == null ? void 0 : _d.vercel) == null ? void 0 : _e.teamSlug;
     if (!teamSlug && !previewDeploymentSuffix) {
-      return [microFrontendConfig.getZone(zone).production.host];
+      return [microfrontendConfig.getZone(zone).production.host];
     }
     const suffix = previewDeploymentSuffix ? `.${previewDeploymentSuffix}` : `-${teamSlug}.vercel.app`;
     return [
       `${parsedProjectName}-git-([a-zA-Z0-9-]+)${suffix}`,
-      microFrontendConfig.getZone(zone).production.host
+      microfrontendConfig.getZone(zone).production.host
     ];
   }
-  static validateOverrideDomain(microFrontendConfig, zone, domain) {
+  static validateOverrideDomain(microfrontendConfig, zone, domain) {
     return new RegExp(
-      `^${_Overrides.validOverrideDomainsForZone(microFrontendConfig, zone).join(
+      `^${_Overrides.validOverrideDomainsForZone(microfrontendConfig, zone).join(
         "|"
       )}$`
     ).test(domain);
@@ -504,7 +510,7 @@ var Application = class {
   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(
+      throw new MicrofrontendError(
         `Invalid assetPrefix for application "${name}". Must not start or end with a slash.`,
         { type: "zone", subtype: "invalid_asset_prefix" }
       );
@@ -515,13 +521,13 @@ var Application = class {
           continue;
         }
         if (p.endsWith("/")) {
-          throw new MicroFrontendError(
+          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(
+          throw new MicrofrontendError(
             `Invalid path for application "${name}". ${p} must start with a slash.`,
             { type: "zone", subtype: "invalid_path" }
           );
@@ -555,10 +561,10 @@ var Application = class {
   }
 };
 
-// src/config/common/micro-frontend-config.ts
+// src/config/common/microfrontend-config.ts
 var SUPPORTED_VERSIONS = ["1"];
 var DEFAULT_LOCAL_PROXY_PORT = 3024;
-var MicroFrontendConfigCommon = class {
+var MicrofrontendConfigCommon = class {
   constructor({
     config,
     overrides
@@ -566,7 +572,7 @@ var MicroFrontendConfigCommon = class {
     this.zones = {};
     var _a, _b, _c;
     if (!SUPPORTED_VERSIONS.includes(config.version)) {
-      throw new MicroFrontendError(
+      throw new MicrofrontendError(
         `Unsupported version: ${config.version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
           ", "
         )}`,
@@ -594,7 +600,7 @@ var MicroFrontendConfigCommon = class {
   static getConfigFromEnv() {
     const config = process.env.MFE_CONFIG;
     if (!config) {
-      throw new MicroFrontendError(`Missing "MFE_CONFIG" in environment.`, {
+      throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
         type: "config",
         subtype: "not_found_in_env"
       });
@@ -613,8 +619,8 @@ var MicroFrontendConfigCommon = class {
   getZone(name) {
     const zone = this.zones[name];
     if (!zone) {
-      throw new MicroFrontendError(
-        `Could not find micro-frontends configuration for application "${name}"`,
+      throw new MicrofrontendError(
+        `Could not find microfrontends configuration for application "${name}"`,
         {
           type: "zone",
           subtype: "not_found"
@@ -634,8 +640,8 @@ var MicroFrontendConfigCommon = class {
   getDefaultZone() {
     const zone = Object.values(this.zones).find((z) => z.default);
     if (!zone) {
-      throw new MicroFrontendError(
-        `Could not find default zone in micro-frontends configuration`,
+      throw new MicrofrontendError(
+        `Could not find default zone in microfrontends configuration`,
         {
           type: "zone",
           subtype: "not_found"
@@ -687,8 +693,8 @@ var MicroFrontendConfigCommon = class {
     };
   }
   write(_) {
-    throw new MicroFrontendError(
-      `Writing to file to disk requires using an instance of "MicroFrontendConfig".`,
+    throw new MicrofrontendError(
+      `Writing to file to disk requires using an instance of "MicrofrontendConfig".`,
       { type: "config", subtype: "unsupported_operation" }
     );
   }
@@ -1049,7 +1055,7 @@ var validateSchema = (configString) => {
   const validate = ajv.compile(SCHEMA);
   const isValid = validate(parsedConfig);
   if (!isValid) {
-    throw new MicroFrontendError(
+    throw new MicrofrontendError(
       `Invalid config: ${ajv.errorsText(validate.errors)}`,
       { type: "config", subtype: "does_not_match_schema" }
     );
@@ -1059,7 +1065,7 @@ var validateSchema = (configString) => {
 var SUPPORTED_VERSIONS2 = ["1"];
 var validateVersion = (version) => {
   if (!SUPPORTED_VERSIONS2.includes(version)) {
-    throw new MicroFrontendError(
+    throw new MicrofrontendError(
       `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS2.join(
         ", "
       )}`,
@@ -1092,7 +1098,7 @@ function validateMainPath(applicationConfigsById) {
           return !matcher.test(defaultRoute);
         });
         if (!isValid) {
-          throw new MicroFrontendError(
+          throw new MicrofrontendError(
             `default route "${defaultRoute}" cannot be used for "${id}" because it is matched by "${otherId}"`,
             { type: "config", subtype: "invalid_main_path" }
           );
@@ -1105,7 +1111,7 @@ function validateMainPath(applicationConfigsById) {
         return matcher.test(defaultRoute);
       });
       if (!isValid) {
-        throw new MicroFrontendError(
+        throw new MicrofrontendError(
           `default route "${defaultRoute}" is not included by the routing config for application "${id}"`,
           { type: "config", subtype: "invalid_main_path" }
         );
@@ -1168,7 +1174,7 @@ var validatePaths = (applicationConfigsById) => {
     );
   });
   if (errors.length) {
-    throw new MicroFrontendError(`Invalid paths: ${errors.join(", ")}`, {
+    throw new MicrofrontendError(`Invalid paths: ${errors.join(", ")}`, {
       type: "config",
       subtype: "conflicting_paths"
     });
@@ -1202,13 +1208,13 @@ function validatePathExpression(path3) {
 var validateDefaults = (applicationConfigsById) => {
   const defaultApplicationIds = Object.entries(applicationConfigsById).reduce((acc, [id, app]) => app.default ? [...acc, id] : acc, []);
   if (defaultApplicationIds.length === 0) {
-    throw new MicroFrontendError(
+    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(
+    throw new MicrofrontendError(
       `Only one default application is allowed. Found ${defaultApplicationIds.join(", ")}.`,
       { type: "config", subtype: "multiple_default_applications" }
     );
@@ -1220,7 +1226,7 @@ var validateOptions = (options) => {
     if (!/^[a-zA-Z]{2,}\.[a-zA-Z]{2,}$/.test(
       options.vercel.previewDeploymentSuffix
     )) {
-      throw new MicroFrontendError(
+      throw new MicrofrontendError(
         `Invalid preview deployment suffix: ${options.vercel.previewDeploymentSuffix}. Should have be formatted like "vercel.app".`,
         { type: "config", subtype: "invalid_preview_deployment_suffix" }
       );
@@ -1275,9 +1281,15 @@ function convertV1ConfigToV2Config(config, fromApp) {
       )
     };
   }
+  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: fromApp
+    partOf: defaultApplication[0]
   };
 }
 
@@ -1292,8 +1304,8 @@ function writeFile(outputPath, config, prettify) {
   );
 }
 
-// src/config/micro-frontend-config.ts
-var MicroFrontendConfig = class extends MicroFrontendConfigCommon {
+// src/config/microfrontend-config.ts
+var MicrofrontendConfig = class extends MicrofrontendConfigCommon {
   static validate(configString) {
     const config = validateSchema(configString);
     validateVersion(config.version);
@@ -1306,9 +1318,9 @@ var MicroFrontendConfig = class extends MicroFrontendConfigCommon {
   static fromEnv({
     cookies
   }) {
-    return new MicroFrontendConfigCommon({
-      config: MicroFrontendConfig.validate(
-        MicroFrontendConfigCommon.getConfigFromEnv()
+    return new MicrofrontendConfigCommon({
+      config: MicrofrontendConfig.validate(
+        MicrofrontendConfigCommon.getConfigFromEnv()
       ),
       overrides: Overrides.parseOverrides(cookies)
     });
@@ -1318,11 +1330,11 @@ var MicroFrontendConfig = class extends MicroFrontendConfigCommon {
   }) {
     try {
       const config = import_node_fs2.default.readFileSync(filePath, "utf-8");
-      return new MicroFrontendConfig({
-        config: MicroFrontendConfig.validate(config)
+      return new MicrofrontendConfig({
+        config: MicrofrontendConfig.validate(config)
       });
     } catch (e) {
-      throw MicroFrontendError.handle(e, {
+      throw MicrofrontendError.handle(e, {
         fileName: filePath
       });
     }
@@ -1345,150 +1357,1435 @@ var MicroFrontendConfig = class extends MicroFrontendConfigCommon {
   }
 };
 
-// src/bin/local-proxy.ts
-var MFE_DEBUG = process.env.MFE_DEBUG;
-var mfeDebug = (message) => {
-  if (MFE_DEBUG === "true" || MFE_DEBUG === "1") {
-    console.log(message);
+// src/config-v2/schema/utils/is-default-app.ts
+function isDefaultApp(a) {
+  return !("routing" in a);
+}
+
+// src/config-v2/errors.ts
+var MicrofrontendError2 = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "MicrofrontendsError";
+    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/microfrontends";
+    this.type = (opts == null ? void 0 : opts.type) ?? "unknown";
+    this.subtype = opts == null ? void 0 : opts.subtype;
+    Error.captureStackTrace(this, MicrofrontendError2);
   }
-};
-var LocalProxy = class {
-  constructor(config, {
-    localApps,
-    proxyPort
-  }) {
-    this.config = config;
-    this.localApps = localApps;
-    this.proxyPort = proxyPort ?? this.config.getLocalProxyPort();
-    this.proxy = import_http_proxy.default.createProxyServer({ secure: true });
-    this.proxy.on("error", (err, req, res) => {
-      if (res instanceof http.ServerResponse) {
-        res.writeHead(500, {
-          "Content-Type": "text/plain"
-        });
-      }
-      const target = this.getTarget(req);
-      res.end(
-        `Error proxying request to ${target.application}. Is the server running locally on port ${target.port}?`
-      );
-      console.error(`Error proxying request for ${target.application}: `, err);
-    });
+  isKnown() {
+    return this.type !== "unknown";
   }
-  static fromFile(filePath, {
-    localApps,
-    proxyPort
-  }) {
-    const config = MicroFrontendConfig.fromFile({ filePath });
-    return new LocalProxy(config, { localApps, proxyPort });
+  isUnknown() {
+    return !this.isKnown();
   }
-  getDefaultHost(config) {
-    const defaultApp = config.getDefaultZone();
-    return this.getApplicationTarget(defaultApp);
+  /**
+   * Converts an error to a MicrofrontendsError.
+   * @param original - The original error to convert.
+   * @returns The converted MicrofrontendsError.
+   */
+  static convert(original, opts) {
+    if (opts == null ? void 0 : opts.fileName) {
+      const err = MicrofrontendError2.convertFSError(original, opts.fileName);
+      if (err) {
+        return err;
+      }
+    }
+    if (original.message.includes(
+      "Code generation from strings disallowed for this context"
+    )) {
+      return new MicrofrontendError2(original.message, {
+        type: "config",
+        subtype: "unsupported_validation_env",
+        source: "ajv"
+      });
+    }
+    return new MicrofrontendError2(original.message);
   }
-  getApplicationTarget(application) {
-    var _a, _b;
-    const useDev = this.localApps.includes(application.name);
-    let host = useDev ? application.development.local : application.production;
-    if ((_b = (_a = application.overrides) == null ? void 0 : _a.environment) == null ? void 0 : _b.host) {
-      host = application.overrides.environment;
+  static convertFSError(original, fileName) {
+    if (original instanceof Error && "code" in original) {
+      if (original.code === "ENOENT") {
+        return new MicrofrontendError2(`Could not find "${fileName}"`, {
+          type: "config",
+          subtype: "unable_to_read_file",
+          source: "fs"
+        });
+      }
+      if (original.code === "EACCES") {
+        return new MicrofrontendError2(
+          `Permission denied while accessing "${fileName}"`,
+          {
+            type: "config",
+            subtype: "invalid_permissions",
+            source: "fs"
+          }
+        );
+      }
     }
-    const protocol = host.protocol;
-    const hostname = host.host;
-    const port = host.port;
-    return {
-      url: host.toUrl(),
-      protocol,
-      hostname,
-      port,
-      application: application.name
-    };
+    if (original instanceof SyntaxError) {
+      return new MicrofrontendError2(
+        `Failed to parse "${fileName}": Invalid JSON format.`,
+        {
+          type: "config",
+          subtype: "invalid_syntax",
+          source: "fs"
+        }
+      );
+    }
+    return null;
   }
   /**
-   * To enable preview deployments in localhost, we need to intercept some auth requests
-   * and make sure they proxy to the correct domain. The toolbar will initiate the `vercel-auth-redirect`
-   * with a `_host_override` param so that we can properly trigger the redirect flow for the
-   * protected host.
+   * Handles an unknown error and returns a MicrofrontendsError instance.
+   * @param err - The error to handle.
+   * @returns A MicrofrontendsError instance.
    */
-  getAuthTarget(request2, config) {
-    var _a, _b;
-    const url = new URL(request2.url ?? "", `http://${request2.headers.host}`);
-    const isAuthRedirect = (_a = request2.url) == null ? void 0 : _a.startsWith(
-      "/.well-known/vercel-auth-redirect"
-    );
-    const isSsoRedirect = (_b = request2.url) == null ? void 0 : _b.startsWith("/sso-api");
-    const isJWTRedirect = url.searchParams.has("_vercel_jwt");
-    const defaultHost = this.getDefaultHost(config);
-    let hostname = null;
-    let path3 = request2.url;
-    if (isAuthRedirect) {
-      hostname = url.searchParams.get("_host_override");
-    }
-    if (isSsoRedirect) {
-      hostname = "vercel.com";
+  static handle(err, opts) {
+    if (err instanceof MicrofrontendError2) {
+      return err;
     }
-    if (isJWTRedirect) {
-      hostname = url.searchParams.get("_host_override");
-      url.searchParams.delete("_host_override");
-      path3 = `${url.pathname}${url.search}`;
+    if (err instanceof Error) {
+      return MicrofrontendError2.convert(err, opts);
     }
-    if (!hostname) {
-      return void 0;
+    if (typeof err === "object" && err !== null) {
+      if ("message" in err && typeof err.message === "string") {
+        return MicrofrontendError2.convert(new Error(err.message), opts);
+      }
     }
-    return { ...defaultHost, path: path3, hostname, protocol: "https", port: 443 };
+    return new MicrofrontendError2("An unknown error occurred");
   }
-  getTarget(request2) {
-    const cookies = (0, import_cookie.parse)(request2.headers.cookie || "");
-    const cookieOverrides = Overrides.parseOverrides(
-      Object.entries(cookies).map(([name, value]) => ({ name, value }))
+};
+
+// src/config-v2/microfrontends-config/isomorphic/validation.ts
+var import_path_to_regexp2 = require("path-to-regexp");
+var SUPPORTED_VERSIONS3 = ["2"];
+var validateConfigVersion = (version) => {
+  if (!SUPPORTED_VERSIONS3.includes(version)) {
+    throw new MicrofrontendError2(
+      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS3.join(
+        ", "
+      )}`,
+      { type: "config", subtype: "unsupported_version" }
     );
-    const hasOverrides = Object.keys(cookieOverrides.applications).length > 0;
-    const config = hasOverrides ? new MicroFrontendConfig({
-      config: this.config.serialize().config,
-      overrides: cookieOverrides
-    }) : this.config;
-    const path3 = request2.url;
-    if (!path3) {
-      return this.getDefaultHost(config);
-    }
-    const authTarget = this.getAuthTarget(request2, config);
-    if (authTarget) {
-      return authTarget;
+  }
+};
+var validateConfigPaths = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
+  }
+  const pathsByApplicationId = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const [id, app] of Object.entries(applicationConfigsById)) {
+    if (isDefaultApp(app)) {
+      continue;
     }
-    const url = new URL(`http://example.com${path3}`);
-    const pathname = url.pathname;
-    for (const application of Object.values(config.getAllApplications())) {
-      if (application.routing) {
-        for (const group of application.routing.matches) {
-          for (const childPath of group.paths) {
-            const regexp = (0, import_path_to_regexp2.pathToRegexp)(childPath);
-            if (regexp.test(pathname)) {
-              const target = this.getApplicationTarget(application);
-              mfeDebug(
-                `routing ${path3} to '${target.application}' at ${target.hostname}`
-              );
-              return { path: path3, ...target };
-            }
-          }
-          if (application.routing.assetPrefix) {
-            const pattern = (0, import_path_to_regexp2.pathToRegexp)(
-              `/${application.routing.assetPrefix}/:path+`
+    for (const pathMatch of app.routing) {
+      for (const path3 of pathMatch.paths) {
+        const tokens = (0, import_path_to_regexp2.parse)(path3);
+        for (const token of tokens.slice(0, -1)) {
+          if (typeof token !== "string") {
+            errors.push(
+              `Path ${path3} may only have a :wildcard in the last path component`
             );
-            if (pattern.test(pathname)) {
-              const target = this.getApplicationTarget(application);
-              mfeDebug(
-                `routing ${path3} to '${target.application}' at ${target.hostname}`
-              );
-              return { path: path3, ...target };
-            }
           }
         }
+        const existing = pathsByApplicationId.get(path3);
+        if (existing) {
+          existing.applications.push(id);
+        } else {
+          pathsByApplicationId.set(path3, {
+            applications: [id],
+            matcher: (0, import_path_to_regexp2.pathToRegexp)(path3),
+            applicationId: id
+          });
+        }
       }
     }
-    const defaultHost = this.getDefaultHost(config);
-    mfeDebug(
-      `no matching routes, routing ${path3} to default application: ${JSON.stringify(defaultHost)}`
+  }
+  const entries = Array.from(pathsByApplicationId.entries());
+  entries.forEach(([path3, { applications: ids, matcher, applicationId }]) => {
+    if (ids.length > 1) {
+      errors.push(
+        `Duplicate path "${path3}" for applications "${ids.join(", ")}"`
+      );
+    }
+    entries.forEach(
+      ([
+        matchPath,
+        { applications: matchIds, applicationId: matchApplicationId }
+      ]) => {
+        if (path3 === matchPath) {
+          return;
+        }
+        if (applicationId === matchApplicationId) {
+          return;
+        }
+        if (matcher.test(matchPath)) {
+          const source = `"${path3}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const destination = `"${matchPath}" of application${matchIds.length > 0 ? "s" : ""} ${matchIds.join(", ")}`;
+          errors.push(
+            `Overlapping path detected between ${source} and ${destination}`
+          );
+        }
+      }
     );
-    return { path: path3, ...defaultHost };
+  });
+  if (errors.length) {
+    throw new MicrofrontendError2(`Invalid paths: ${errors.join(", ")}`, {
+      type: "config",
+      subtype: "conflicting_paths"
+    });
+  }
+};
+var validateAppPaths = (name, app) => {
+  for (const group of app.routing) {
+    for (const p of group.paths) {
+      if (p === "/") {
+        continue;
+      }
+      if (p.endsWith("/")) {
+        throw new MicrofrontendError2(
+          `Invalid path for application "${name}". ${p} must not end with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
+      if (!p.startsWith("/")) {
+        throw new MicrofrontendError2(
+          `Invalid path for application "${name}". ${p} must start with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
+    }
+  }
+};
+var validateConfigDefaultApplication = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
+  }
+  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 MicrofrontendError2(
+      `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 MicrofrontendError2(
+      `Only one application can omit "routing". Found ${applicationsWithRoutingNames.length - Object.keys(applicationConfigsById).length > 1}.`,
+      { type: "config", subtype: "multiple_default_applications" }
+    );
+  }
+};
+var validateConfigOptions = (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 MicrofrontendError2(
+        `Invalid preview deployment suffix: ${options.vercel.previewDeploymentSuffix}. Should have be formatted like "vercel.app".`,
+        { type: "config", subtype: "invalid_preview_deployment_suffix" }
+      );
+    }
+  }
+};
+
+// src/config-v2/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-v2/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-v2/microfrontends-config/isomorphic/host.ts
+var Host2 = class {
+  constructor(hostConfig, options) {
+    const { protocol = "https", host, port } = hostConfig;
+    this.protocol = protocol;
+    this.host = host;
+    this.port = Host2.getPort({ port, protocol: this.protocol });
+    this.local = options == null ? void 0 : options.isLocal;
+  }
+  isLocal() {
+    return this.local || this.host === "localhost" || this.host === "127.0.0.1";
+  }
+  static getPort({
+    protocol,
+    port
+  }) {
+    if (!port) {
+      if (protocol === "http") {
+        return 80;
+      }
+      return 443;
+    }
+    return port;
+  }
+  isDefaultPort() {
+    return this.port === Host2.getPort({ protocol: this.protocol });
+  }
+  toString(opts = {}) {
+    const url = this.toUrl(opts);
+    return url.toString().replace(/\/$/, "");
+  }
+  toUrl(opts = {}) {
+    const { includeDefaultPort } = opts;
+    const url = `${this.protocol}://${this.host}${this.isDefaultPort() && !includeDefaultPort ? "" : `:${this.port}`}`;
+    return new URL(url);
+  }
+};
+var LocalHost = class extends Host2 {
+  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-v2/microfrontends-config/isomorphic/application.ts
+var Application2 = class {
+  constructor(name, {
+    app,
+    overrides,
+    isDefault
+  }) {
+    var _a, _b;
+    this.name = name;
+    this.development = {
+      local: new LocalHost({
+        appName: name,
+        ...(_a = app.development) == null ? void 0 : _a.local
+      }),
+      fallback: ((_b = app.development) == null ? void 0 : _b.fallback) ? new Host2(app.development.fallback) : void 0
+    };
+    this.production = app.production ? new Host2(app.production) : void 0;
+    this.vercel = app.vercel;
+    this.overrides = (overrides == null ? void 0 : overrides.environment) ? {
+      environment: new Host2(overrides.environment)
+    } : void 0;
+    this.default = isDefault ?? false;
+    this.serialized = app;
+  }
+  isDefault() {
+    return this.default;
+  }
+  getAssetPrefix() {
+    return generateAssetPrefixFromName({ name: this.name });
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+var DefaultApplication = class extends Application2 {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    super(name, {
+      app,
+      overrides,
+      isDefault: true
+    });
+    this.default = true;
+    this.production = new Host2(app.production);
+  }
+};
+var ChildApplication = class extends Application2 {
+  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-v2/microfrontends-config/isomorphic/index.ts
+var import_jsonc_parser2 = require("jsonc-parser");
+
+// src/config-v2/microfrontends-config/utils/get-config-from-env.ts
+function getConfigStringFromEnv() {
+  const config = process.env.MFE_CONFIG;
+  if (!config) {
+    throw new MicrofrontendError2(`Missing "MFE_CONFIG" in environment.`, {
+      type: "config",
+      subtype: "not_found_in_env"
+    });
+  }
+  return config;
+}
+
+// src/config-v2/schema/utils/is-main-config.ts
+function isMainConfig(c) {
+  return !("partOf" in c);
+}
+
+// src/config-v2/microfrontends-config/client/index.ts
+var import_path_to_regexp3 = require("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);
+        }
+      }
+    }
+    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(path3) {
+    if (!path3.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path3]) {
+      return this.pathCache[path3];
+    }
+    const pathname = new URL(path3, "https://example.com").pathname;
+    for (const [name, application] of Object.entries(this.applications)) {
+      if (application.routing) {
+        for (const group of application.routing) {
+          for (const childPath of group.paths) {
+            const regexp = (0, import_path_to_regexp3.pathToRegexp)(childPath);
+            if (regexp.test(pathname)) {
+              this.pathCache[path3] = name;
+              return name;
+            }
+          }
+        }
+      }
+    }
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path3] = defaultApplication[0];
+    return defaultApplication[0];
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config-v2/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX2 = "vercel-microfrontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX2}:env:`;
+
+// src/config-v2/overrides/is-override-cookie.ts
+function isOverrideCookie(cookie) {
+  var _a;
+  return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX2));
+}
+
+// src/config-v2/overrides/get-override-from-cookie.ts
+function getOverrideFromCookie(cookie) {
+  if (!isOverrideCookie(cookie) || !cookie.value)
+    return;
+  return {
+    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
+    host: cookie.value
+  };
+}
+
+// src/config-v2/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-v2/microfrontends-config/isomorphic/constants.ts
+var DEFAULT_LOCAL_PROXY_PORT2 = 3024;
+
+// src/config-v2/microfrontends-config/isomorphic/index.ts
+var MicrofrontendConfigIsomorphic = class {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    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
+        }
+      );
+    }
+    if (isMainConfig(config) && !this.defaultApplication) {
+      throw new MicrofrontendError2(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    this.config = config;
+    this.options = config.options;
+    this.serialized = {
+      config,
+      overrides,
+      meta
+    };
+  }
+  static validate(config) {
+    const c = typeof config === "string" ? (0, import_jsonc_parser2.parse)(config) : config;
+    if (isMainConfig(c)) {
+      validateConfigVersion(c.version);
+      validateConfigPaths(c.applications);
+      validateConfigDefaultApplication(c.applications);
+    }
+    validateConfigOptions(c.options);
+    return c;
+  }
+  static fromEnv({
+    meta,
+    cookies
+  }) {
+    return new MicrofrontendConfigIsomorphic({
+      config: (0, import_jsonc_parser2.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;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getApplicationsByType() {
+    return {
+      defaultApplication: this.defaultApplication,
+      applications: Object.values(this.childApplications)
+    };
+  }
+  getChildApplications() {
+    return Object.values(this.childApplications);
+  }
+  getAllApplications() {
+    return [
+      this.defaultApplication,
+      ...Object.values(this.childApplications)
+    ].filter(Boolean);
+  }
+  getApplication(name) {
+    var _a;
+    if (((_a = this.defaultApplication) == null ? void 0 : _a.name) === name) {
+      return this.defaultApplication;
+    }
+    const app = this.childApplications[name];
+    if (!app) {
+      throw new MicrofrontendError2(
+        `Could not find microfrontends configuration for application "${name}"`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    return app;
+  }
+  getApplicationByProjectId(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;
+      }
+    );
+  }
+  /**
+   * Returns the default application. This can throw if the default application
+   * is undefined ( )
+   */
+  getDefaultApplication() {
+    if (!this.defaultApplication) {
+      throw new MicrofrontendError2(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    return this.defaultApplication;
+  }
+  /**
+   * Returns the configured port for the local proxy
+   */
+  getLocalProxyPort() {
+    var _a, _b;
+    return ((_b = (_a = this.config.options) == null ? void 0 : _a.localProxy) == null ? void 0 : _b.port) ?? DEFAULT_LOCAL_PROXY_PORT2;
+  }
+  /**
+   * Serializes the class back to the Schema type.
+   *
+   * NOTE: This is used when writing the config to disk and must always match the input Schema
+   */
+  toSchemaJson() {
+    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 new MicrofrontendConfigClient({
+      applications
+    });
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config-v2/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;
+    this.provider = config.provider;
+    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 MicrofrontendError2(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    this.defaultApplication = defaultApplication;
+  }
+};
+
+// src/config-v2/microfrontends/util/is-main-config.ts
+function isMainConfig2(c) {
+  return !("partOf" in c);
+}
+
+// src/config-v2/microfrontends/server/index.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = require("path");
+
+// src/config-v2/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-v2/microfrontends/isomorphic/index.ts
+var Microfrontends = class {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    if (isMainConfig(config)) {
+      this.config = new MicrofrontendMainConfig({ config, overrides, meta });
+    } else {
+      this.config = new MicrofrontendChildConfig({ config, overrides, meta });
+    }
+  }
+  isChildConfig() {
+    return this.config instanceof MicrofrontendChildConfig;
+  }
+  static fromEnv({
+    cookies,
+    meta
+  }) {
+    const config = MicrofrontendConfigIsomorphic.fromEnv({
+      cookies,
+      meta
+    });
+    return new Microfrontends(config.serialize());
+  }
+};
+
+// src/config-v2/microfrontends/server/validation.ts
+var import_jsonc_parser3 = require("jsonc-parser");
+var import_ajv2 = require("ajv");
+
+// schema/schema-v2.json
+var schema_v2_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $ref: "#/definitions/Config",
+  definitions: {
+    Config: {
+      anyOf: [
+        {
+          $ref: "#/definitions/MainConfig"
+        },
+        {
+          $ref: "#/definitions/ChildConfig"
+        }
+      ]
+    },
+    MainConfig: {
+      type: "object",
+      properties: {
+        $schema: {
+          type: "string"
+        },
+        version: {
+          type: "string",
+          const: "2"
+        },
+        options: {
+          $ref: "#/definitions/Options"
+        },
+        remotes: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/Application"
+          },
+          description: "Applications that only serve a subset of the microfrontend routes only need to reference the name of the primary application that owns the full microfrontends configuration."
+        },
+        provider: {
+          $ref: "#/definitions/Provider"
+        },
+        applications: {
+          $ref: "#/definitions/ApplicationRouting",
+          description: "Mapping of application names to the routes that they host. Only needs to be defined in the application that owns the primary microfrontend domain"
+        }
+      },
+      required: ["applications", "provider", "version"]
+    },
+    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`."
+        }
+      }
+    },
+    Application: {
+      anyOf: [
+        {
+          $ref: "#/definitions/DefaultApplication"
+        },
+        {
+          $ref: "#/definitions/ChildApplication"
+        }
+      ]
+    },
+    DefaultApplication: {
+      type: "object",
+      properties: {
+        vercel: {
+          $ref: "#/definitions/Vercel"
+        },
+        development: {
+          $ref: "#/definitions/Development"
+        },
+        production: {
+          $ref: "#/definitions/HostConfig"
+        }
+      },
+      required: ["production"]
+    },
+    Vercel: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Vercel project ID"
+        },
+        routeSpeedInsightsToDefaultZone: {
+          type: "boolean"
+        }
+      },
+      required: ["projectId"]
+    },
+    Development: {
+      type: "object",
+      properties: {
+        local: {
+          $ref: "#/definitions/LocalHostConfig"
+        },
+        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."
+        }
+      }
+    },
+    LocalHostConfig: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "The hostname or IP address of the server. This can be a domain name (e.g., `example.com`) or an IP address (e.g., `192.168.1.1`)."
+        },
+        protocol: {
+          type: "string",
+          enum: ["http", "https"],
+          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "http" for local development, "https" for otherwise'
+        },
+        port: {
+          type: "number",
+          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS."
+        }
+      }
+    },
+    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 "http" for local development, "https" for otherwise'
+        },
+        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."
+        }
+      },
+      required: ["host"]
+    },
+    ChildApplication: {
+      type: "object",
+      properties: {
+        vercel: {
+          $ref: "#/definitions/Vercel"
+        },
+        development: {
+          $ref: "#/definitions/Development"
+        },
+        routing: {
+          $ref: "#/definitions/Routing",
+          description: "Groups of path expressions that are routed to this application."
+        },
+        production: {
+          $ref: "#/definitions/HostConfig"
+        }
+      },
+      required: ["routing"]
+    },
+    Routing: {
+      type: "array",
+      items: {
+        $ref: "#/definitions/PathGroup"
+      }
+    },
+    PathGroup: {
+      type: "object",
+      properties: {
+        group: {
+          type: "string",
+          description: "Optional group name for the paths"
+        },
+        flag: {
+          type: "string",
+          description: "flag name that can be used to enable/disable all paths in the group"
+        },
+        routeToDefaultApplication: {
+          type: "boolean",
+          description: "True to route the request to the default application for this micro-frontends set-up. This must be `true` when using `flag` or when you want to use custom logic to make the routing decision for this group of paths."
+        },
+        paths: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["paths"]
+    },
+    Provider: {
+      type: "string",
+      enum: ["vercel", "other"]
+    },
+    ApplicationRouting: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/definitions/Application"
+      }
+    },
+    ChildConfig: {
+      type: "object",
+      properties: {
+        $schema: {
+          type: "string"
+        },
+        version: {
+          type: "string",
+          const: "2"
+        },
+        options: {
+          $ref: "#/definitions/Options"
+        },
+        remotes: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/Application"
+          },
+          description: "Applications that only serve a subset of the microfrontend routes only need to reference the name of the primary application that owns the full microfrontends configuration."
+        },
+        partOf: {
+          type: "string",
+          description: "Applications that only serve a subset of the microfrontend routes only need to reference the name of the primary application that owns the full microfrontends configuration."
+        }
+      },
+      required: ["partOf", "version"]
+    }
+  }
+};
+
+// src/config-v2/schema/utils/load.ts
+var SCHEMA2 = schema_v2_default;
+
+// src/config-v2/microfrontends/server/validation.ts
+function validateSchema2(configString) {
+  const parsedConfig = (0, import_jsonc_parser3.parse)(configString);
+  const ajv = new import_ajv2.Ajv();
+  const validate = ajv.compile(SCHEMA2);
+  const isValid = validate(parsedConfig);
+  if (!isValid) {
+    throw new MicrofrontendError(
+      `Invalid config: ${ajv.errorsText(validate.errors)}`,
+      { type: "config", subtype: "does_not_match_schema" }
+    );
+  }
+  return parsedConfig;
+}
+
+// src/config-v2/microfrontends/server/index.ts
+var MicrofrontendsServer = class extends Microfrontends {
+  /**
+   * Writes the configuration to a file.
+   */
+  writeConfig(opts = {
+    pretty: true
+  }) {
+    const outputPath = getOutputFilePath();
+    import_node_fs3.default.mkdirSync((0, import_node_path4.dirname)(outputPath), { recursive: true });
+    import_node_fs3.default.writeFileSync(
+      outputPath,
+      JSON.stringify(
+        this.config.toSchemaJson(),
+        null,
+        opts.pretty ?? true ? 2 : void 0
+      )
+    );
+  }
+  // --------- Static Methods ---------
+  /**
+   * Generates a MicrofrontendsServer instance from an unknown object.
+   */
+  static fromUnknown({
+    config,
+    cookies,
+    meta
+  }) {
+    const overrides = cookies ? parseOverrides(cookies) : void 0;
+    if (typeof config === "string") {
+      return new MicrofrontendsServer({
+        config: MicrofrontendsServer.validate(config),
+        overrides,
+        meta
+      });
+    }
+    if (typeof config === "object") {
+      return new MicrofrontendsServer({
+        config,
+        overrides,
+        meta
+      });
+    }
+    throw new MicrofrontendError2(
+      "Invalid config: must be a string or an object",
+      { type: "config", subtype: "does_not_match_schema" }
+    );
+  }
+  /**
+   * Generates a MicrofrontendsServer instance from the environment.
+   * Uses additional validation that is only available when in a node runtime
+   */
+  static fromEnv({
+    cookies,
+    meta
+  }) {
+    return new MicrofrontendsServer({
+      config: MicrofrontendsServer.validate(getConfigStringFromEnv()),
+      overrides: parseOverrides(cookies),
+      meta
+    });
+  }
+  /**
+   * Validates the configuration against the JSON schema
+   */
+  static validate(config) {
+    if (typeof config === "string") {
+      const c = validateSchema2(config);
+      return c;
+    }
+    return config;
+  }
+  /*
+   * Generates a MicrofrontendsServer instance from a file.
+   */
+  static fromFile({
+    filePath,
+    cookies,
+    meta
+  }) {
+    try {
+      const config = import_node_fs3.default.readFileSync(filePath, "utf-8");
+      return new MicrofrontendsServer({
+        config: MicrofrontendsServer.validate(config),
+        overrides: cookies ? parseOverrides(cookies) : void 0,
+        meta
+      });
+    } catch (e) {
+      throw MicrofrontendError2.handle(e, {
+        fileName: filePath
+      });
+    }
+  }
+  /*
+   * Generates a MicrofrontendMainConfig instance from a file.
+   */
+  static fromMainConfigFile({
+    filePath,
+    overrides
+  }) {
+    try {
+      const config = import_node_fs3.default.readFileSync(filePath, "utf-8");
+      const validatedConfig = MicrofrontendsServer.validate(config);
+      if (!isMainConfig(validatedConfig)) {
+        throw new MicrofrontendError2(
+          `${filePath} is not a main microfrontend config`,
+          {
+            type: "config",
+            subtype: "invalid_main_path"
+          }
+        );
+      }
+      const [defaultApplication] = Object.entries(validatedConfig.applications).filter(([, app]) => isDefaultApp(app)).map(([name]) => name);
+      if (!defaultApplication) {
+        throw new MicrofrontendError2(
+          `No default application found. At least one application needs to be the default by omitting routing.`,
+          { type: "config", subtype: "no_default_application" }
+        );
+      }
+      return new MicrofrontendsServer({
+        config: validatedConfig,
+        overrides,
+        meta: { fromApp: defaultApplication }
+      });
+    } catch (e) {
+      throw MicrofrontendError2.handle(e, {
+        fileName: filePath
+      });
+    }
+  }
+};
+
+// src/bin/local-proxy.ts
+var MFE_DEBUG = process.env.MFE_DEBUG;
+var mfeDebug = (message) => {
+  if (MFE_DEBUG === "true" || MFE_DEBUG === "1") {
+    console.log(message);
+  }
+};
+function isV2Config(c) {
+  return "isMainConfig" in c;
+}
+var LocalProxy = class {
+  constructor(config, {
+    localApps,
+    proxyPort
+  }) {
+    this.config = config;
+    this.localApps = localApps;
+    this.proxyPort = proxyPort ?? this.config.getLocalProxyPort();
+    this.proxy = import_http_proxy.default.createProxyServer({ secure: true });
+    this.proxy.on("error", (err, req, res) => {
+      if (res instanceof http.ServerResponse) {
+        res.writeHead(500, {
+          "Content-Type": "text/plain"
+        });
+      }
+      const target = this.getTarget(req);
+      res.end(
+        `Error proxying request to ${target.application}. Is the server running locally on port ${target.port}?`
+      );
+      console.error(`Error proxying request for ${target.application}: `, err);
+    });
+  }
+  static fromFile(filePath, {
+    localApps,
+    proxyPort
+  }) {
+    let configV2;
+    try {
+      configV2 = MicrofrontendsServer.fromMainConfigFile({
+        filePath
+      });
+    } catch (error) {
+      if ((0, import_types2.isNativeError)(error)) {
+        mfeDebug(`unable to parse v2 version: ${error.toString()}`);
+      }
+    }
+    if (configV2) {
+      if (isMainConfig2(configV2.config)) {
+        return new LocalProxy(configV2.config, { localApps, proxyPort });
+      }
+      throw new Error("Got child config after parsing main config");
+    }
+    const configV1 = MicrofrontendConfig.fromFile({ filePath });
+    return new LocalProxy(configV1, { localApps, proxyPort });
+  }
+  getDefaultHost(config) {
+    let defaultApp;
+    if (isV2Config(config)) {
+      defaultApp = config.getDefaultApplication();
+    } else {
+      defaultApp = config.getDefaultZone();
+    }
+    return this.getApplicationTarget(defaultApp);
+  }
+  getApplicationTarget(application) {
+    var _a, _b;
+    const useDev = this.localApps.includes(application.name);
+    let host = useDev ? application.development.local : application.production;
+    if (!host) {
+      throw new Error(
+        `${application.name} does not have a production host configured`
+      );
+    }
+    if ((_b = (_a = application.overrides) == null ? void 0 : _a.environment) == null ? void 0 : _b.host) {
+      host = application.overrides.environment;
+    }
+    const protocol = host.protocol;
+    const hostname = host.host;
+    const port = host.port;
+    return {
+      url: host.toUrl(),
+      protocol,
+      hostname,
+      port,
+      application: application.name
+    };
+  }
+  /**
+   * To enable preview deployments in localhost, we need to intercept some auth requests
+   * and make sure they proxy to the correct domain. The toolbar will initiate the `vercel-auth-redirect`
+   * with a `_host_override` param so that we can properly trigger the redirect flow for the
+   * protected host.
+   */
+  getAuthTarget(request2, config) {
+    var _a, _b;
+    const url = new URL(request2.url ?? "", `http://${request2.headers.host}`);
+    const isAuthRedirect = (_a = request2.url) == null ? void 0 : _a.startsWith(
+      "/.well-known/vercel-auth-redirect"
+    );
+    const isSsoRedirect = (_b = request2.url) == null ? void 0 : _b.startsWith("/sso-api");
+    const isJWTRedirect = url.searchParams.has("_vercel_jwt");
+    const defaultHost = this.getDefaultHost(config);
+    let hostname = null;
+    let path3 = request2.url;
+    if (isAuthRedirect) {
+      hostname = url.searchParams.get("_host_override");
+    }
+    if (isSsoRedirect) {
+      hostname = "vercel.com";
+    }
+    if (isJWTRedirect) {
+      hostname = url.searchParams.get("_host_override");
+      url.searchParams.delete("_host_override");
+      path3 = `${url.pathname}${url.search}`;
+    }
+    if (!hostname) {
+      return void 0;
+    }
+    return { ...defaultHost, path: path3, hostname, protocol: "https", port: 443 };
+  }
+  getConfigWithOverrides(cookies) {
+    if (isV2Config(this.config)) {
+      const cookieOverrides2 = parseOverrides(
+        Object.entries(cookies).map(([name, value]) => ({ name, value }))
+      );
+      const hasOverrides2 = Object.keys(cookieOverrides2.applications).length > 0;
+      const fromApp = this.config.getDefaultApplication().name;
+      const serialized = this.config.serialize().config;
+      if (!isMainConfig(serialized)) {
+        throw new Error("unreachable");
+      }
+      return hasOverrides2 ? new MicrofrontendMainConfig({
+        config: serialized,
+        meta: { fromApp },
+        overrides: cookieOverrides2
+      }) : this.config;
+    }
+    const cookieOverrides = Overrides.parseOverrides(
+      Object.entries(cookies).map(([name, value]) => ({ name, value }))
+    );
+    const hasOverrides = Object.keys(cookieOverrides.applications).length > 0;
+    return hasOverrides ? new MicrofrontendConfig({
+      config: this.config.serialize().config,
+      overrides: cookieOverrides
+    }) : this.config;
+  }
+  getTarget(request2) {
+    const cookies = (0, import_cookie.parse)(request2.headers.cookie || "");
+    const config = this.getConfigWithOverrides(cookies);
+    const path3 = request2.url;
+    if (!path3) {
+      return this.getDefaultHost(config);
+    }
+    const authTarget = this.getAuthTarget(request2, config);
+    if (authTarget) {
+      return authTarget;
+    }
+    const url = new URL(`http://example.com${path3}`);
+    const pathname = url.pathname;
+    if (isV2Config(config)) {
+      const target = this.findMatchingApplicationV2(
+        path3,
+        pathname,
+        config.getChildApplications()
+      );
+      if (target)
+        return target;
+    } else {
+      const target = this.findMatchingApplicationV1(
+        path3,
+        pathname,
+        config.getAllApplications()
+      );
+      if (target)
+        return target;
+    }
+    const defaultHost = this.getDefaultHost(config);
+    mfeDebug(
+      `no matching routes, routing ${path3} to default application: ${JSON.stringify(defaultHost)}`
+    );
+    return { path: path3, ...defaultHost };
+  }
+  findMatchingApplicationV1(path3, pathname, applications) {
+    for (const application of Object.values(applications)) {
+      if (application.routing) {
+        for (const group of application.routing.matches) {
+          for (const childPath of group.paths) {
+            const regexp = (0, import_path_to_regexp4.pathToRegexp)(childPath);
+            if (regexp.test(pathname)) {
+              const target = this.getApplicationTarget(application);
+              mfeDebug(
+                `routing ${path3} to '${target.application}' at ${target.hostname}`
+              );
+              return { path: path3, ...target };
+            }
+          }
+          if (application.routing.assetPrefix) {
+            const pattern = (0, import_path_to_regexp4.pathToRegexp)(
+              `/${application.routing.assetPrefix}/:path+`
+            );
+            if (pattern.test(pathname)) {
+              const target = this.getApplicationTarget(application);
+              mfeDebug(
+                `routing ${path3} to '${target.application}' at ${target.hostname}`
+              );
+              return { path: path3, ...target };
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  findMatchingApplicationV2(path3, pathname, applications) {
+    for (const application of Object.values(applications)) {
+      for (const group of application.routing) {
+        for (const childPath of group.paths) {
+          const regexp = (0, import_path_to_regexp4.pathToRegexp)(childPath);
+          if (regexp.test(pathname)) {
+            const target = this.getApplicationTarget(application);
+            mfeDebug(
+              `routing ${path3} to '${target.application}' at ${target.hostname}`
+            );
+            return { path: path3, ...target };
+          }
+        }
+      }
+    }
+    return null;
   }
   // Handles requests that return data from the local proxy itself.
   // Returns true if the request was handled, false otherwise.