@vercel/microfrontends 0.14.0 → 0.16.0

package/dist/utils/mfe-port.js

@@ -1,1165 +1,22 @@
 // src/utils/mfe-port.ts
-import path6 from "node:path";
-import fs8 from "node:fs";
-
-// src/config/types.ts
-var isDefaultApplicationConfig = (app) => app.default && typeof app.routing === "undefined";
-
-// src/config/microfrontend-config.ts
-import fs2 from "node:fs";
-
-// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
-import path from "node:path";
-
-// src/config-v2/microfrontends/server/constants.ts
-var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
-var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
-
-// src/utils/is-vercel.ts
-function isVercel() {
-  return process.env.VERCEL === "1";
-}
-
-// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
-function getOutputFilePath() {
-  if (isVercel()) {
-    return path.join(
-      ".vercel",
-      MFE_CONFIG_DEFAULT_FILE_PATH,
-      MFE_CONFIG_DEFAULT_FILE_NAME
-    );
-  }
-  return path.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
-}
-
-// src/config/errors.ts
-var MicrofrontendError = 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, MicrofrontendError);
-  }
-  isKnown() {
-    return this.type !== "unknown";
-  }
-  isUnknown() {
-    return !this.isKnown();
-  }
-  /**
-   * 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 = MicrofrontendError.convertFSError(original, opts.fileName);
-      if (err) {
-        return err;
-      }
-    }
-    if (original.message.includes(
-      "Code generation from strings disallowed for this context"
-    )) {
-      return new MicrofrontendError(original.message, {
-        type: "config",
-        subtype: "unsupported_validation_env",
-        source: "ajv"
-      });
-    }
-    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}"`, {
-          type: "config",
-          subtype: "unable_to_read_file",
-          source: "fs"
-        });
-      }
-      if (original.code === "EACCES") {
-        return new MicrofrontendError(
-          `Permission denied while accessing "${fileName}"`,
-          {
-            type: "config",
-            subtype: "invalid_permissions",
-            source: "fs"
-          }
-        );
-      }
-    }
-    if (original instanceof SyntaxError) {
-      return new MicrofrontendError(
-        `Failed to parse "${fileName}": Invalid JSON format.`,
-        {
-          type: "config",
-          subtype: "invalid_syntax",
-          source: "fs"
-        }
-      );
-    }
-    return null;
-  }
-  /**
-   * Handles an unknown error and returns a MicrofrontendsError instance.
-   * @param err - The error to handle.
-   * @returns A MicrofrontendsError instance.
-   */
-  static handle(err, opts) {
-    if (err instanceof MicrofrontendError) {
-      return err;
-    }
-    if (err instanceof Error) {
-      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 new MicrofrontendError("An unknown error occurred");
-  }
-};
-
-// 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");
-      }
-      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();
-        }
-      }
-      tag = args.join(options.joinString);
-      tag = tag.replace(/\s/g, options.joinString);
-      if (options.lowercaseOnly)
-        tag = tag.toLowerCase();
-      tag = tag.replace(options.regexRemovePattern, (match) => {
-        if (match === options.joinString)
-          return match;
-        return "";
-      });
-      if (tag.length > options.maxLen)
-        tag = tag.substring(0, options.maxLen);
-      tag = tag.replace(reJoinString, options.joinString);
-      return tag;
-    }
-  };
-}
-var urlSafeString = buildUrlSafeString().generate;
-function makeUrlSafe(name) {
-  return urlSafeString(name.replace(/\//g, "-")).replace(/^-*/g, "").replace(/-*$/g, "");
-}
-
-// src/config/overrides/config.ts
-var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
-var _Overrides = class {
-  constructor(config) {
-    this.config = config;
-  }
-  static getAppEnvOverrideCookieName(zone) {
-    return `${_Overrides.overrideEnvCookiePrefix}${zone}`;
-  }
-  static isOverrideCookie(cookie) {
-    var _a;
-    return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
-  }
-  static getOverrideFromCookie(cookie) {
-    if (!_Overrides.isOverrideCookie(cookie) || !cookie.value)
-      return;
-    return {
-      zone: cookie.name.replace(_Overrides.overrideEnvCookiePrefix, ""),
-      host: cookie.value
-    };
-  }
-  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 }
-      };
-    });
-    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];
-    }
-    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);
-  }
-  serialize() {
-    return this.config;
-  }
-};
-var Overrides = _Overrides;
-Overrides.overrideEnvCookiePrefix = `${OVERRIDES_COOKIE_PREFIX}:env:`;
-
-// src/config/common/host.ts
-var Host = class {
-  constructor({ protocol, host, port }) {
-    this.protocol = protocol || "https";
-    this.host = host;
-    this.port = Host.getPort({ port, protocol: this.protocol });
-    this.serialized = {
-      protocol,
-      host,
-      ...port ? { port } : void 0
-    };
-  }
-  isLocal() {
-    return 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 === Host.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);
-  }
-  serialize() {
-    return this.serialized;
-  }
-};
-
-// src/config/common/application.ts
-var Application = class {
-  constructor(name, {
-    app,
-    overrides
-  }) {
-    Application.validate(name, app);
-    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
-    };
-    this.production = new Host(app.production);
-    this.vercel = app.vercel;
-    this.overrides = (overrides == null ? void 0 : overrides.environment) ? {
-      environment: new Host(overrides.environment)
-    } : void 0;
-  }
-  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" }
-          );
-        }
-      }
-    }
-  }
-  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
-    };
-  }
-};
-
-// src/config/common/microfrontend-config.ts
-var SUPPORTED_VERSIONS = ["1"];
-var DEFAULT_LOCAL_PROXY_PORT = 3024;
-var MicrofrontendConfigCommon = class {
-  constructor({
-    config,
-    overrides
-  }) {
-    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" }
-      );
-    }
-    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
-      });
-    }
-    this.config = config;
-    this.name = config.name;
-    this.version = config.version;
-    this.options = config.options;
-    this.$schema = config.$schema;
-  }
-  isOverridesDisabled() {
-    var _a, _b;
-    return ((_b = (_a = this.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
-  }
-  static getConfigFromEnv() {
-    const config = process.env.MFE_CONFIG;
-    if (!config) {
-      throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
-        type: "config",
-        subtype: "not_found_in_env"
-      });
-    }
-    return config;
-  }
-  static fromEnv(_) {
-    throw new Error("Not implemented");
-  }
-  getConfig() {
-    return this.config;
-  }
-  getAllApplications() {
-    return Object.values(this.zones);
-  }
-  getZone(name) {
-    const zone = this.zones[name];
-    if (!zone) {
-      throw new MicrofrontendError(
-        `Could not find microfrontends configuration for application "${name}"`,
-        {
-          type: "zone",
-          subtype: "not_found"
-        }
-      );
-    }
-    return zone;
-  }
-  getApplicationByProjectId(projectId) {
-    return Object.values(this.zones).find(
-      (zone) => {
-        var _a;
-        return ((_a = zone.vercel) == null ? void 0 : _a.projectId) === projectId;
-      }
-    );
-  }
-  getDefaultZone() {
-    const zone = Object.values(this.zones).find((z) => z.default);
-    if (!zone) {
-      throw new MicrofrontendError(
-        `Could not find default zone in microfrontends configuration`,
-        {
-          type: "zone",
-          subtype: "not_found"
-        }
-      );
-    }
-    return zone;
-  }
-  /**
-   * 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_PORT;
-  }
-  /**
-   * 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() {
-    const applications = {};
-    for (const [name, zone] of Object.entries(this.zones)) {
-      applications[name] = zone.serialize();
-    }
-    return {
-      $schema: this.$schema,
-      name: this.name,
-      version: this.version,
-      options: this.options,
-      applications
-    };
-  }
-  serialize() {
-    var _a;
-    const applications = {};
-    for (const [name, zone] of Object.entries(this.zones)) {
-      applications[name] = zone.serialize();
-    }
-    return {
-      config: {
-        name: this.name,
-        version: this.version,
-        applications,
-        options: this.options,
-        $schema: this.$schema
-      },
-      overrides: (_a = this.overrides) == null ? void 0 : _a.serialize()
-    };
-  }
-  write(_) {
-    throw new MicrofrontendError(
-      `Writing to file to disk requires using an instance of "MicrofrontendConfig".`,
-      { type: "config", subtype: "unsupported_operation" }
-    );
-  }
-};
-
-// src/config/utils/get-output-file-path.ts
-import path2 from "node:path";
-
-// src/config/constants.ts
-var MFE_CONFIG_DEFAULT_FILE_PATH2 = "micro-frontends";
-var MFE_CONFIG_DEFAULT_FILE_NAME2 = "micro-frontends.config.json";
-
-// src/config/utils/get-output-file-path.ts
-function getOutputFilePath2() {
-  if (isVercel()) {
-    return path2.join(
-      ".vercel",
-      MFE_CONFIG_DEFAULT_FILE_PATH2,
-      MFE_CONFIG_DEFAULT_FILE_NAME2
-    );
-  }
-  return path2.join(MFE_CONFIG_DEFAULT_FILE_PATH2, MFE_CONFIG_DEFAULT_FILE_NAME2);
-}
-
-// src/config/validation.ts
-import { parse } from "jsonc-parser";
-import { pathToRegexp, parse as parsePathRegexp } from "path-to-regexp";
-import { Ajv } from "ajv";
-
-// schema/schema.json
-var schema_default = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $ref: "#/definitions/Config",
-  definitions: {
-    Config: {
-      type: "object",
-      properties: {
-        version: {
-          type: "string"
-        },
-        $schema: {
-          type: "string"
-        },
-        name: {
-          type: "string",
-          description: 'Name for the micro-frontend site (eg. "vercel.com", "vercel-site" etc.).'
-        },
-        applications: {
-          $ref: "#/definitions/ApplicationConfigsById"
-        },
-        options: {
-          $ref: "#/definitions/Options",
-          description: "Optional configuration for the entire micro-frontends setup."
-        }
-      },
-      required: ["version", "applications"],
-      description: "Configuration for micro-frontend applications\n\nTODO: Add proxy configuration"
-    },
-    ApplicationConfigsById: {
-      type: "object",
-      additionalProperties: {
-        $ref: "#/definitions/ApplicationConfig"
-      }
-    },
-    ApplicationConfig: {
-      anyOf: [
-        {
-          $ref: "#/definitions/DefaultApplicationConfig"
-        },
-        {
-          $ref: "#/definitions/CommonApplicationConfig"
-        }
-      ],
-      description: "A Micro-Frontend Deployment Target"
-    },
-    DefaultApplicationConfig: {
-      type: "object",
-      properties: {
-        default: {
-          type: "boolean",
-          const: true,
-          description: "The default application is used no other application is matched via the routing config"
-        },
-        routing: {
-          $ref: "#/definitions/Routing"
-        },
-        development: {
-          type: "object",
-          properties: {
-            local: {
-              $ref: "#/definitions/HostConfig"
-            },
-            fallback: {
-              $ref: "#/definitions/HostConfig",
-              description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
-            },
-            task: {
-              type: "string",
-              description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
-            }
-          },
-          required: ["local"]
-        },
-        production: {
-          $ref: "#/definitions/HostConfig"
-        },
-        metadata: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        },
-        federation: {
-          type: "object",
-          properties: {
-            exposes: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  name: {
-                    type: "string",
-                    description: "The name of the module - should be used when importing the module from another application"
-                  },
-                  path: {
-                    type: "string",
-                    description: "Relative path to the module within its `application`"
-                  }
-                },
-                required: ["name", "path"]
-              },
-              description: "Modules that are exposed by this application"
-            },
-            uses: {
-              type: "array",
-              items: {
-                type: "string"
-              },
-              description: "Modules that are used by this application. Only the name of the module is required."
-            }
-          }
-        },
-        vercel: {
-          $ref: "#/definitions/Vercel"
-        }
-      },
-      required: ["default", "development", "production"]
-    },
-    Routing: {
-      type: "object",
-      properties: {
-        assetPrefix: {
-          type: "string",
-          description: "[assetPrefix] for the application"
-        },
-        matches: {
-          type: "array",
-          items: {
-            $ref: "#/definitions/PathGroup"
-          },
-          description: "Path expressions that are routed to this application."
-        }
-      },
-      required: ["matches"]
-    },
-    PathGroup: {
-      type: "object",
-      properties: {
-        group: {
-          type: "string",
-          description: "Optional group name for the paths"
-        },
-        options: {
-          type: "object",
-          properties: {
-            flag: {
-              type: "string",
-              description: "flag name that can be used to enable/disable all paths in the group"
-            }
-          }
-        },
-        paths: {
-          type: "array",
-          items: {
-            type: "string"
-          }
-        }
-      },
-      required: ["paths"]
-    },
-    HostConfig: {
-      type: "object",
-      properties: {
-        protocol: {
-          type: "string",
-          enum: ["http", "https"],
-          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "https"'
-        },
-        host: {
-          type: "string",
-          description: "The hostname or IP address of the server. This can be a domain name (e.g., `example.com`) or an IP address (e.g., `192.168.1.1`)."
-        },
-        port: {
-          type: "number",
-          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS.\n\nThis field is optional and can be omitted if the default ports for the specified protocol are used"
-        }
-      },
-      required: ["host"]
-    },
-    Vercel: {
-      type: "object",
-      properties: {
-        projectId: {
-          type: "string",
-          description: "Vercel project ID"
-        },
-        projectName: {
-          type: "string",
-          description: "Vercel project name (temporary until we can use project ID)"
-        },
-        defaultRoute: {
-          type: "string",
-          description: "The default route for the application. Used to render screenshots, favicons, and provide direct zone links"
-        },
-        routeSpeedInsightsToDefaultZone: {
-          type: "boolean",
-          description: "Whether to route Speed Insights to the default zone or each individual microfrontend."
-        }
-      },
-      required: ["projectId"]
-    },
-    CommonApplicationConfig: {
-      type: "object",
-      properties: {
-        default: {
-          type: "boolean",
-          const: false,
-          description: "The default application is used no other application is matched via the routing config"
-        },
-        routing: {
-          $ref: "#/definitions/Routing"
-        },
-        development: {
-          type: "object",
-          properties: {
-            local: {
-              $ref: "#/definitions/HostConfig"
-            },
-            fallback: {
-              $ref: "#/definitions/HostConfig",
-              description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
-            },
-            task: {
-              type: "string",
-              description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
-            }
-          },
-          required: ["local"]
-        },
-        production: {
-          $ref: "#/definitions/HostConfig"
-        },
-        metadata: {
-          type: "object",
-          additionalProperties: {
-            type: "string"
-          }
-        },
-        federation: {
-          type: "object",
-          properties: {
-            exposes: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  name: {
-                    type: "string",
-                    description: "The name of the module - should be used when importing the module from another application"
-                  },
-                  path: {
-                    type: "string",
-                    description: "Relative path to the module within its `application`"
-                  }
-                },
-                required: ["name", "path"]
-              },
-              description: "Modules that are exposed by this application"
-            },
-            uses: {
-              type: "array",
-              items: {
-                type: "string"
-              },
-              description: "Modules that are used by this application. Only the name of the module is required."
-            }
-          }
-        },
-        vercel: {
-          $ref: "#/definitions/Vercel"
-        }
-      },
-      required: ["default", "development", "production", "routing"]
-    },
-    Options: {
-      type: "object",
-      properties: {
-        vercel: {
-          $ref: "#/definitions/VercelOptions",
-          description: "Micro-Frontends wide options for Vercel."
-        },
-        localProxy: {
-          $ref: "#/definitions/LocalProxyOptions",
-          description: "Options for local proxy."
-        }
-      }
-    },
-    VercelOptions: {
-      type: "object",
-      properties: {
-        previewDeploymentSuffix: {
-          type: "string",
-          description: "If your team uses a custom Preview Deployment Suffix, please specify it here. See https://vercel.com/docs/deployments/preview-deployment-suffix. The default is `vercel.app`."
-        },
-        teamSlug: {
-          type: "string",
-          description: "Team slug for the Vercel team"
-        },
-        disableOverrides: {
-          type: "boolean",
-          description: "If you want to disable the overrides for the site. For example, if you are managing rewrites between applications externally, you may wish to disable the overrides on the toolbar as they will have no effect."
-        }
-      }
-    },
-    LocalProxyOptions: {
-      type: "object",
-      properties: {
-        port: {
-          type: "number",
-          description: "The port number used by the local proxy server.\n\nThe default is `3024`."
-        }
-      }
-    }
-  }
-};
-
-// src/config/utils/load-schema.ts
-var SCHEMA = schema_default;
-
-// src/config/validation.ts
-var validateSchema = (configString) => {
-  const parsedConfig = parse(configString);
-  const ajv = new Ajv();
-  const validate = ajv.compile(SCHEMA);
-  const isValid = validate(parsedConfig);
-  if (!isValid) {
-    throw new MicrofrontendError(
-      `Invalid config: ${ajv.errorsText(validate.errors)}`,
-      { type: "config", subtype: "does_not_match_schema" }
-    );
-  }
-  return parsedConfig;
-};
-var SUPPORTED_VERSIONS2 = ["1"];
-var validateVersion = (version) => {
-  if (!SUPPORTED_VERSIONS2.includes(version)) {
-    throw new MicrofrontendError(
-      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS2.join(
-        ", "
-      )}`,
-      { type: "config", subtype: "unsupported_version" }
-    );
-  }
-};
-function validateMainPath(applicationConfigsById) {
-  for (const [id, app] of Object.entries(applicationConfigsById)) {
-    const { defaultRoute } = app.vercel ?? {};
-    if (!defaultRoute) {
-      continue;
-    }
-    if (isDefaultApplicationConfig(app)) {
-      const pathsWithApp = [];
-      for (const [otherId, otherApp] of Object.entries(
-        applicationConfigsById
-      )) {
-        if (isDefaultApplicationConfig(otherApp)) {
-          continue;
-        }
-        pathsWithApp.push({
-          id: otherId,
-          paths: otherApp.routing.matches.flatMap((match) => match.paths)
-        });
-      }
-      for (const { id: otherId, paths } of pathsWithApp) {
-        const isValid = paths.every((path7) => {
-          const matcher = pathToRegexp(path7);
-          return !matcher.test(defaultRoute);
-        });
-        if (!isValid) {
-          throw new MicrofrontendError(
-            `default route "${defaultRoute}" cannot be used for "${id}" because it is matched by "${otherId}"`,
-            { type: "config", subtype: "invalid_main_path" }
-          );
-        }
-      }
-    } else {
-      const allPaths = app.routing.matches.flatMap((match) => match.paths);
-      const isValid = allPaths.some((path7) => {
-        const matcher = pathToRegexp(path7);
-        return matcher.test(defaultRoute);
-      });
-      if (!isValid) {
-        throw new MicrofrontendError(
-          `default route "${defaultRoute}" is not included by the routing config for application "${id}"`,
-          { type: "config", subtype: "invalid_main_path" }
-        );
-      }
-    }
-  }
-}
-var validatePaths = (applicationConfigsById) => {
-  const pathsByApplicationId = /* @__PURE__ */ new Map();
-  const errors = [];
-  for (const [id, app] of Object.entries(applicationConfigsById)) {
-    if (isDefaultApplicationConfig(app)) {
-      continue;
-    }
-    for (const pathMatch of app.routing.matches) {
-      for (const path7 of pathMatch.paths) {
-        const maybeError = validatePathExpression(path7);
-        if (maybeError) {
-          errors.push(maybeError);
-        }
-        const existing = pathsByApplicationId.get(path7);
-        if (existing) {
-          existing.applications.push(id);
-        } else {
-          pathsByApplicationId.set(path7, {
-            applications: [id],
-            matcher: pathToRegexp(path7),
-            applicationId: id
-          });
-        }
-      }
-    }
-  }
-  const entries = Array.from(pathsByApplicationId.entries());
-  entries.forEach(([path7, { applications: ids, matcher, applicationId }]) => {
-    if (ids.length > 1) {
-      errors.push(
-        `Duplicate path "${path7}" for applications "${ids.join(", ")}"`
-      );
-    }
-    entries.forEach(
-      ([
-        matchPath,
-        { applications: matchIds, applicationId: matchApplicationId }
-      ]) => {
-        if (path7 === matchPath) {
-          return;
-        }
-        if (applicationId === matchApplicationId) {
-          return;
-        }
-        if (matcher.test(matchPath)) {
-          const source = `"${path7}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
-          const destination = `"${matchPath}" of application${matchIds.length > 0 ? "s" : ""} ${matchIds.join(", ")}`;
-          errors.push(
-            `Overlapping path detected between ${source} and ${destination}`
-          );
-        }
-      }
-    );
-  });
-  if (errors.length) {
-    throw new MicrofrontendError(`Invalid paths: ${errors.join(", ")}`, {
-      type: "config",
-      subtype: "conflicting_paths"
-    });
-  }
-};
-var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
-function validatePathExpression(path7) {
-  const tokens = parsePathRegexp(path7);
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (token === void 0) {
-      return `token ${i} in ${path7} is undefined, this shouldn't happen`;
-    }
-    if (typeof token !== "string") {
-      if (token.pattern !== PATH_DEFAULT_PATTERN) {
-        return `Path ${path7} cannot use a regular expression wildcard`;
-      }
-      if (token.prefix !== "/") {
-        return `Wildcard :${token.name} must be immediately after a / in ${path7}`;
-      }
-      if (token.suffix) {
-        return `Wildcard suffix on :${token.name} is not allowed. Suffixes are not supported`;
-      }
-      if (token.modifier && i !== tokens.length - 1) {
-        return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path7}. Modifiers are only allowed in the last path component`;
-      }
-    }
-  }
-  return void 0;
-}
-var validateDefaults = (applicationConfigsById) => {
-  const defaultApplicationIds = Object.entries(applicationConfigsById).reduce((acc, [id, app]) => app.default ? [...acc, id] : acc, []);
-  if (defaultApplicationIds.length === 0) {
-    throw new MicrofrontendError(
-      `No default application found. At least one application must be marked as default.`,
-      { type: "config", subtype: "no_default_application" }
-    );
-  }
-  if (defaultApplicationIds.length > 1) {
-    throw new MicrofrontendError(
-      `Only one default application is allowed. Found ${defaultApplicationIds.join(", ")}.`,
-      { type: "config", subtype: "multiple_default_applications" }
-    );
-  }
-};
-var validateOptions = (options) => {
-  var _a;
-  if ((_a = options == null ? void 0 : options.vercel) == null ? void 0 : _a.previewDeploymentSuffix) {
-    if (!/^[a-zA-Z]{2,}\.[a-zA-Z]{2,}$/.test(
-      options.vercel.previewDeploymentSuffix
-    )) {
-      throw new MicrofrontendError(
-        `Invalid preview deployment suffix: ${options.vercel.previewDeploymentSuffix}. Should have be formatted like "vercel.app".`,
-        { type: "config", subtype: "invalid_preview_deployment_suffix" }
-      );
-    }
-  }
-};
-
-// src/config/utils/convert.ts
-function convertV1RoutingToV2Routing(routing) {
-  return routing.matches.map((group) => {
-    var _a;
-    return {
-      group: group.group,
-      flag: (_a = group.options) == null ? void 0 : _a.flag,
-      paths: group.paths
-    };
-  });
-}
-function convertV1ApplicationToV2Application(application) {
-  const common = {
-    production: application.production,
-    development: application.development,
-    vercel: application.vercel
-  };
-  if (application.default) {
-    return common;
-  }
-  return {
-    ...common,
-    routing: convertV1RoutingToV2Routing(application.routing)
-  };
-}
-function convertV1ConfigToV2Config(config, fromApp) {
-  if (!config.applications[fromApp]) {
-    throw new Error(`Application "${fromApp}" not found in the config`);
-  }
-  const common = {
-    version: "2",
-    options: config.options
-  };
-  if (config.applications[fromApp].default) {
-    return {
-      ...common,
-      applications: Object.fromEntries(
-        Object.entries(config.applications).map(([id, application]) => [
-          id,
-          convertV1ApplicationToV2Application(application)
-        ])
-      )
-    };
-  }
-  const defaultApplication = Object.entries(config.applications).find(
-    ([, application]) => application.default
-  );
-  if (!defaultApplication) {
-    throw new Error("No default application found in the config");
-  }
-  return {
-    ...common,
-    partOf: defaultApplication[0]
-  };
-}
-
-// src/config/utils/write-file.ts
-import fs from "node:fs";
-import { dirname } from "node:path";
-function writeFile(outputPath, config, prettify) {
-  fs.mkdirSync(dirname(outputPath), { recursive: true });
-  fs.writeFileSync(
-    outputPath,
-    JSON.stringify(config, null, prettify ? 2 : void 0)
-  );
-}
-
-// src/config/microfrontend-config.ts
-var MicrofrontendConfig = class extends MicrofrontendConfigCommon {
-  static validate(configString) {
-    const config = validateSchema(configString);
-    validateVersion(config.version);
-    validatePaths(config.applications);
-    validateMainPath(config.applications);
-    validateDefaults(config.applications);
-    validateOptions(config.options);
-    return config;
-  }
-  static fromEnv({
-    cookies
-  }) {
-    return new MicrofrontendConfigCommon({
-      config: MicrofrontendConfig.validate(
-        MicrofrontendConfigCommon.getConfigFromEnv()
-      ),
-      overrides: Overrides.parseOverrides(cookies)
-    });
-  }
-  static fromFile({
-    filePath
-  }) {
-    try {
-      const config = fs2.readFileSync(filePath, "utf-8");
-      return new MicrofrontendConfig({
-        config: MicrofrontendConfig.validate(config)
-      });
-    } catch (e) {
-      throw MicrofrontendError.handle(e, {
-        fileName: filePath
-      });
-    }
-  }
-  /**
-   * Writes the configuration to a file.
-   */
-  write(fromApp, opts = {}) {
-    const { pretty = true, versions = ["v1", "v2"] } = opts;
-    const config = this.toSchemaJson();
-    if (versions.includes("v1")) {
-      const outputPath = getOutputFilePath2();
-      writeFile(outputPath, config, pretty);
-    }
-    if (versions.includes("v2")) {
-      const outputPath = getOutputFilePath();
-      const v2Config = convertV1ConfigToV2Config(config, fromApp);
-      writeFile(outputPath, v2Config, pretty);
-    }
-  }
-};
+import path5 from "node:path";
+import fs6 from "node:fs";
 
-// src/config-v2/microfrontends/server/index.ts
-import fs7 from "node:fs";
-import { dirname as dirname4, join as join2 } from "node:path";
+// src/config/microfrontends/server/index.ts
+import fs5 from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
 
-// src/config-v2/overrides/constants.ts
-var OVERRIDES_COOKIE_PREFIX2 = "vercel-micro-frontends-override";
-var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX2}:env:`;
+// src/config/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
 
-// src/config-v2/overrides/is-override-cookie.ts
+// src/config/overrides/is-override-cookie.ts
 function isOverrideCookie(cookie) {
   var _a;
-  return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX2));
+  return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
 }
 
-// src/config-v2/overrides/get-override-from-cookie.ts
+// src/config/overrides/get-override-from-cookie.ts
 function getOverrideFromCookie(cookie) {
   if (!isOverrideCookie(cookie) || !cookie.value)
     return;
@@ -1169,7 +26,7 @@ function getOverrideFromCookie(cookie) {
   };
 }
 
-// src/config-v2/overrides/parse-overrides.ts
+// src/config/overrides/parse-overrides.ts
 function parseOverrides(cookies) {
   const overridesConfig = { applications: {} };
   cookies.forEach((cookie) => {
@@ -1183,15 +40,15 @@ function parseOverrides(cookies) {
   return overridesConfig;
 }
 
-// src/config-v2/errors.ts
-var MicrofrontendError2 = class extends Error {
+// src/config/errors.ts
+var MicrofrontendError = 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);
+    Error.captureStackTrace(this, MicrofrontendError);
   }
   isKnown() {
     return this.type !== "unknown";
@@ -1206,7 +63,7 @@ var MicrofrontendError2 = class extends Error {
    */
   static convert(original, opts) {
     if (opts == null ? void 0 : opts.fileName) {
-      const err = MicrofrontendError2.convertFSError(original, opts.fileName);
+      const err = MicrofrontendError.convertFSError(original, opts.fileName);
       if (err) {
         return err;
       }
@@ -1214,25 +71,25 @@ var MicrofrontendError2 = class extends Error {
     if (original.message.includes(
       "Code generation from strings disallowed for this context"
     )) {
-      return new MicrofrontendError2(original.message, {
+      return new MicrofrontendError(original.message, {
         type: "config",
         subtype: "unsupported_validation_env",
         source: "ajv"
       });
     }
-    return new MicrofrontendError2(original.message);
+    return new MicrofrontendError(original.message);
   }
   static convertFSError(original, fileName) {
     if (original instanceof Error && "code" in original) {
       if (original.code === "ENOENT") {
-        return new MicrofrontendError2(`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 MicrofrontendError2(
+        return new MicrofrontendError(
           `Permission denied while accessing "${fileName}"`,
           {
             type: "config",
@@ -1243,7 +100,7 @@ var MicrofrontendError2 = class extends Error {
       }
     }
     if (original instanceof SyntaxError) {
-      return new MicrofrontendError2(
+      return new MicrofrontendError(
         `Failed to parse "${fileName}": Invalid JSON format.`,
         {
           type: "config",
@@ -1260,26 +117,26 @@ var MicrofrontendError2 = class extends Error {
    * @returns A MicrofrontendsError instance.
    */
   static handle(err, opts) {
-    if (err instanceof MicrofrontendError2) {
+    if (err instanceof MicrofrontendError) {
       return err;
     }
     if (err instanceof Error) {
-      return MicrofrontendError2.convert(err, opts);
+      return MicrofrontendError.convert(err, opts);
     }
     if (typeof err === "object" && err !== null) {
       if ("message" in err && typeof err.message === "string") {
-        return MicrofrontendError2.convert(new Error(err.message), opts);
+        return MicrofrontendError.convert(new Error(err.message), opts);
       }
     }
-    return new MicrofrontendError2("An unknown error occurred");
+    return new MicrofrontendError("An unknown error occurred");
   }
 };
 
-// src/config-v2/microfrontends-config/utils/get-config-from-env.ts
+// src/config/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.`, {
+    throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
       type: "config",
       subtype: "not_found_in_env"
     });
@@ -1287,21 +144,21 @@ function getConfigStringFromEnv() {
   return config;
 }
 
-// src/config-v2/microfrontends-config/isomorphic/index.ts
-import { parse as parse2 } from "jsonc-parser";
+// src/config/microfrontends-config/isomorphic/index.ts
+import { parse } from "jsonc-parser";
 
-// src/config-v2/schema/utils/is-main-config.ts
+// src/config/schema/utils/is-main-config.ts
 function isMainConfig(c) {
   return !("partOf" in c);
 }
 
-// src/config-v2/schema/utils/is-default-app.ts
+// src/config/schema/utils/is-default-app.ts
 function isDefaultApp(a) {
   return !("routing" in a);
 }
 
-// src/config-v2/microfrontends-config/client/index.ts
-import { pathToRegexp as pathToRegexp2 } from "path-to-regexp";
+// src/config/microfrontends-config/client/index.ts
+import { pathToRegexp } from "path-to-regexp";
 var MicrofrontendConfigClient = class {
   constructor(config, opts) {
     this.pathCache = {};
@@ -1331,21 +188,21 @@ var MicrofrontendConfigClient = class {
   isEqual(other) {
     return JSON.stringify(this.applications) === JSON.stringify(other.applications);
   }
-  getApplicationNameForPath(path7) {
-    if (!path7.startsWith("/")) {
+  getApplicationNameForPath(path6) {
+    if (!path6.startsWith("/")) {
       throw new Error(`Path must start with a /`);
     }
-    if (this.pathCache[path7]) {
-      return this.pathCache[path7];
+    if (this.pathCache[path6]) {
+      return this.pathCache[path6];
     }
-    const pathname = new URL(path7, "https://example.com").pathname;
+    const pathname = new URL(path6, "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 = pathToRegexp2(childPath);
+            const regexp = pathToRegexp(childPath);
             if (regexp.test(pathname)) {
-              this.pathCache[path7] = name;
+              this.pathCache[path6] = name;
               return name;
             }
           }
@@ -1358,7 +215,7 @@ var MicrofrontendConfigClient = class {
     if (!defaultApplication) {
       return null;
     }
-    this.pathCache[path7] = defaultApplication[0];
+    this.pathCache[path6] = defaultApplication[0];
     return defaultApplication[0];
   }
   serialize() {
@@ -1366,13 +223,13 @@ var MicrofrontendConfigClient = class {
   }
 };
 
-// src/config-v2/microfrontends-config/isomorphic/validation.ts
-import { pathToRegexp as pathToRegexp3, parse as parsePathRegexp2 } from "path-to-regexp";
-var SUPPORTED_VERSIONS3 = ["2"];
+// 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_VERSIONS3.includes(version)) {
-    throw new MicrofrontendError2(
-      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS3.join(
+  if (!SUPPORTED_VERSIONS.includes(version)) {
+    throw new MicrofrontendError(
+      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
         ", "
       )}`,
       { type: "config", subtype: "unsupported_version" }
@@ -1390,22 +247,18 @@ var validateConfigPaths = (applicationConfigsById) => {
       continue;
     }
     for (const pathMatch of app.routing) {
-      for (const path7 of pathMatch.paths) {
-        const tokens = parsePathRegexp2(path7);
-        for (const token of tokens.slice(0, -1)) {
-          if (typeof token !== "string") {
-            errors.push(
-              `Path ${path7} may only have a :wildcard in the last path component`
-            );
-          }
+      for (const path6 of pathMatch.paths) {
+        const maybeError = validatePathExpression(path6);
+        if (maybeError) {
+          errors.push(maybeError);
         }
-        const existing = pathsByApplicationId.get(path7);
+        const existing = pathsByApplicationId.get(path6);
         if (existing) {
           existing.applications.push(id);
         } else {
-          pathsByApplicationId.set(path7, {
+          pathsByApplicationId.set(path6, {
             applications: [id],
-            matcher: pathToRegexp3(path7),
+            matcher: pathToRegexp2(path6),
             applicationId: id
           });
         }
@@ -1413,10 +266,10 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  entries.forEach(([path7, { applications: ids, matcher, applicationId }]) => {
+  entries.forEach(([path6, { applications: ids, matcher, applicationId }]) => {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path7}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path6}" for applications "${ids.join(", ")}"`
       );
     }
     entries.forEach(
@@ -1424,14 +277,14 @@ var validateConfigPaths = (applicationConfigsById) => {
         matchPath,
         { applications: matchIds, applicationId: matchApplicationId }
       ]) => {
-        if (path7 === matchPath) {
+        if (path6 === matchPath) {
           return;
         }
         if (applicationId === matchApplicationId) {
           return;
         }
         if (matcher.test(matchPath)) {
-          const source = `"${path7}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const source = `"${path6}" 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}`
@@ -1441,12 +294,37 @@ var validateConfigPaths = (applicationConfigsById) => {
     );
   });
   if (errors.length) {
-    throw new MicrofrontendError2(`Invalid paths: ${errors.join(", ")}`, {
+    throw new MicrofrontendError(`Invalid paths: ${errors.join(", ")}`, {
       type: "config",
       subtype: "conflicting_paths"
     });
   }
 };
+var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
+function validatePathExpression(path6) {
+  const tokens = parsePathRegexp(path6);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === void 0) {
+      return `token ${i} in ${path6} is undefined, this shouldn't happen`;
+    }
+    if (typeof token !== "string") {
+      if (token.pattern !== PATH_DEFAULT_PATTERN) {
+        return `Path ${path6} cannot use a regular expression wildcard`;
+      }
+      if (token.prefix !== "/") {
+        return `Wildcard :${token.name} must be immediately after a / in ${path6}`;
+      }
+      if (token.suffix) {
+        return `Wildcard suffix on :${token.name} is not allowed. Suffixes are not supported`;
+      }
+      if (token.modifier && i !== tokens.length - 1) {
+        return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path6}. Modifiers are only allowed in the last path component`;
+      }
+    }
+  }
+  return void 0;
+}
 var validateAppPaths = (name, app) => {
   for (const group of app.routing) {
     for (const p of group.paths) {
@@ -1454,13 +332,13 @@ var validateAppPaths = (name, app) => {
         continue;
       }
       if (p.endsWith("/")) {
-        throw new MicrofrontendError2(
+        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 MicrofrontendError2(
+        throw new MicrofrontendError(
           `Invalid path for application "${name}". ${p} must start with a slash.`,
           { type: "application", subtype: "invalid_path" }
         );
@@ -1482,20 +360,20 @@ var validateConfigDefaultApplication = (applicationConfigsById) => {
   const numApplicationsWithRouting = applicationsWithRoutingNames.length;
   const numApplicationsWithoutRouting = numApplications - numApplicationsWithRouting;
   if (numApplicationsWithoutRouting === 0) {
-    throw new MicrofrontendError2(
+    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 MicrofrontendError2(
+    throw new MicrofrontendError(
       `Only one application can omit "routing". Found ${applicationsWithRoutingNames.length - Object.keys(applicationConfigsById).length > 1}.`,
       { type: "config", subtype: "multiple_default_applications" }
     );
   }
 };
 
-// src/config-v2/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
+// src/config/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
 var PREFIX = "vc-ap";
 function generateAssetPrefixFromName({
   name
@@ -1506,7 +384,7 @@ function generateAssetPrefixFromName({
   return `${PREFIX}-${name}`;
 }
 
-// src/config-v2/microfrontends-config/isomorphic/utils/generate-port.ts
+// src/config/microfrontends-config/isomorphic/utils/generate-port.ts
 function generatePortFromName({
   name,
   minPort = 3e3,
@@ -1526,13 +404,13 @@ function generatePortFromName({
   return port;
 }
 
-// src/config-v2/microfrontends-config/isomorphic/host.ts
-var Host2 = class {
+// src/config/microfrontends-config/isomorphic/host.ts
+var Host = 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.port = Host.getPort({ port, protocol: this.protocol });
     this.local = options == null ? void 0 : options.isLocal;
   }
   isLocal() {
@@ -1551,7 +429,7 @@ var Host2 = class {
     return port;
   }
   isDefaultPort() {
-    return this.port === Host2.getPort({ protocol: this.protocol });
+    return this.port === Host.getPort({ protocol: this.protocol });
   }
   toString(opts = {}) {
     const url = this.toUrl(opts);
@@ -1563,7 +441,7 @@ var Host2 = class {
     return new URL(url);
   }
 };
-var LocalHost = class extends Host2 {
+var LocalHost = class extends Host {
   constructor({
     appName,
     ...hostConfig
@@ -1575,8 +453,8 @@ var LocalHost = class extends Host2 {
   }
 };
 
-// src/config-v2/microfrontends-config/isomorphic/application.ts
-var Application2 = class {
+// src/config/microfrontends-config/isomorphic/application.ts
+var Application = class {
   constructor(name, {
     app,
     overrides,
@@ -1589,12 +467,12 @@ var Application2 = class {
         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
+      fallback: ((_b = app.development) == null ? void 0 : _b.fallback) ? new Host(app.development.fallback) : void 0
     };
-    this.production = app.production ? new Host2(app.production) : void 0;
+    this.production = app.production ? new Host(app.production) : void 0;
     this.vercel = app.vercel;
     this.overrides = (overrides == null ? void 0 : overrides.environment) ? {
-      environment: new Host2(overrides.environment)
+      environment: new Host(overrides.environment)
     } : void 0;
     this.default = isDefault ?? false;
     this.serialized = app;
@@ -1609,7 +487,7 @@ var Application2 = class {
     return this.serialized;
   }
 };
-var DefaultApplication = class extends Application2 {
+var DefaultApplication = class extends Application {
   constructor(name, {
     app,
     overrides
@@ -1620,13 +498,13 @@ var DefaultApplication = class extends Application2 {
       isDefault: true
     });
     this.default = true;
-    this.production = new Host2(app.production);
+    this.production = new Host(app.production);
   }
   getAssetPrefix() {
     return "";
   }
 };
-var ChildApplication = class extends Application2 {
+var ChildApplication = class extends Application {
   constructor(name, {
     app,
     overrides
@@ -1645,10 +523,10 @@ var ChildApplication = class extends Application2 {
   }
 };
 
-// src/config-v2/microfrontends-config/isomorphic/constants.ts
-var DEFAULT_LOCAL_PROXY_PORT2 = 3024;
+// src/config/microfrontends-config/isomorphic/constants.ts
+var DEFAULT_LOCAL_PROXY_PORT = 3024;
 
-// src/config-v2/microfrontends-config/isomorphic/index.ts
+// src/config/microfrontends-config/isomorphic/index.ts
 var MicrofrontendConfigIsomorphic = class {
   constructor({
     config,
@@ -1689,7 +567,7 @@ var MicrofrontendConfigIsomorphic = class {
       );
     }
     if (isMainConfig(config) && !this.defaultApplication) {
-      throw new MicrofrontendError2(
+      throw new MicrofrontendError(
         `Could not find default application in microfrontends configuration`,
         {
           type: "application",
@@ -1706,7 +584,7 @@ var MicrofrontendConfigIsomorphic = class {
     };
   }
   static validate(config) {
-    const c = typeof config === "string" ? parse2(config) : config;
+    const c = typeof config === "string" ? parse(config) : config;
     if (isMainConfig(c)) {
       validateConfigVersion(c.version);
       validateConfigPaths(c.applications);
@@ -1719,7 +597,7 @@ var MicrofrontendConfigIsomorphic = class {
     cookies
   }) {
     return new MicrofrontendConfigIsomorphic({
-      config: parse2(getConfigStringFromEnv()),
+      config: parse(getConfigStringFromEnv()),
       overrides: parseOverrides(cookies ?? []),
       meta
     });
@@ -1753,7 +631,7 @@ var MicrofrontendConfigIsomorphic = class {
     }
     const app = this.childApplications[name];
     if (!app) {
-      throw new MicrofrontendError2(
+      throw new MicrofrontendError(
         `Could not find microfrontends configuration for application "${name}"`,
         {
           type: "application",
@@ -1781,7 +659,7 @@ var MicrofrontendConfigIsomorphic = class {
    */
   getDefaultApplication() {
     if (!this.defaultApplication) {
-      throw new MicrofrontendError2(
+      throw new MicrofrontendError(
         `Could not find default application in microfrontends configuration`,
         {
           type: "application",
@@ -1796,7 +674,7 @@ var MicrofrontendConfigIsomorphic = class {
    */
   getLocalProxyPort() {
     var _a, _b;
-    return ((_b = (_a = this.config.options) == null ? void 0 : _a.localProxy) == null ? void 0 : _b.port) ?? DEFAULT_LOCAL_PROXY_PORT2;
+    return ((_b = (_a = this.config.options) == null ? void 0 : _a.localProxy) == null ? void 0 : _b.port) ?? DEFAULT_LOCAL_PROXY_PORT;
   }
   /**
    * Serializes the class back to the Schema type.
@@ -1830,7 +708,7 @@ var MicrofrontendConfigIsomorphic = class {
   }
 };
 
-// src/config-v2/microfrontends-config/isomorphic/child.ts
+// src/config/microfrontends-config/isomorphic/child.ts
 var MicrofrontendChildConfig = class extends MicrofrontendConfigIsomorphic {
   constructor({
     config,
@@ -1843,7 +721,7 @@ var MicrofrontendChildConfig = class extends MicrofrontendConfigIsomorphic {
   }
 };
 
-// src/config-v2/microfrontends-config/isomorphic/main.ts
+// src/config/microfrontends-config/isomorphic/main.ts
 var MicrofrontendMainConfig = class extends MicrofrontendConfigIsomorphic {
   constructor({
     config,
@@ -1870,7 +748,7 @@ var MicrofrontendMainConfig = class extends MicrofrontendConfigIsomorphic {
       }
     }
     if (!defaultApplication) {
-      throw new MicrofrontendError2(
+      throw new MicrofrontendError(
         `Could not find default application in microfrontends configuration`,
         {
           type: "application",
@@ -1882,7 +760,7 @@ var MicrofrontendMainConfig = class extends MicrofrontendConfigIsomorphic {
   }
 };
 
-// src/config-v2/microfrontends/isomorphic/index.ts
+// src/config/microfrontends/isomorphic/index.ts
 var Microfrontends = class {
   constructor({
     config,
@@ -1910,26 +788,26 @@ var Microfrontends = class {
   }
 };
 
-// src/config-v2/microfrontends/utils/find-repository-root.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+// src/config/microfrontends/utils/find-repository-root.ts
+import fs from "node:fs";
+import path from "node:path";
 var GIT_DIRECTORY = ".git";
 function findRepositoryRoot(startDir) {
   let currentDir = startDir || process.cwd();
-  while (currentDir !== path3.parse(currentDir).root) {
-    const gitPath = path3.join(currentDir, GIT_DIRECTORY);
-    if (fs3.existsSync(gitPath) && fs3.statSync(gitPath).isDirectory()) {
+  while (currentDir !== path.parse(currentDir).root) {
+    const gitPath = path.join(currentDir, GIT_DIRECTORY);
+    if (fs.existsSync(gitPath) && fs.statSync(gitPath).isDirectory()) {
       return currentDir;
     }
-    currentDir = path3.dirname(currentDir);
+    currentDir = path.dirname(currentDir);
   }
   throw new Error(
     "Repository root not found. Specify the root of the repository with the `repository.root` option."
   );
 }
 
-// src/config-v2/microfrontends/utils/find-package-path.ts
-import { dirname as dirname2 } from "node:path";
+// src/config/microfrontends/utils/find-package-path.ts
+import { dirname } from "node:path";
 import { readFileSync } from "node:fs";
 import fg from "fast-glob";
 var configCache = {};
@@ -1964,7 +842,7 @@ function findPackagePathWithGlob({
       );
     }
     const [packageJsonPath] = matchingPaths;
-    return dirname2(packageJsonPath);
+    return dirname(packageJsonPath);
   } catch (error) {
     return null;
   }
@@ -1984,19 +862,19 @@ function findPackagePath(opts) {
   return result;
 }
 
-// src/config-v2/microfrontends/utils/find-default-package.ts
-import { dirname as dirname3 } from "node:path";
+// src/config/microfrontends/utils/find-default-package.ts
+import { dirname as dirname2 } from "node:path";
 import { readFileSync as readFileSync2 } from "node:fs";
-import { parse as parse3 } from "jsonc-parser";
+import { parse as parse2 } from "jsonc-parser";
 import fg2 from "fast-glob";
 
-// src/config-v2/constants.ts
+// src/config/constants.ts
 var CONFIGURATION_FILENAMES = [
   "microfrontends.jsonc",
   "microfrontends.json"
 ];
 
-// src/config-v2/microfrontends/utils/find-default-package.ts
+// src/config/microfrontends/utils/find-default-package.ts
 var configCache2 = {};
 function findDefaultMicrofrontendsPackages({
   repositoryRoot,
@@ -2019,7 +897,7 @@ function findDefaultMicrofrontendsPackages({
         microfrontendsJsonPath,
         "utf-8"
       );
-      const microfrontendsJson = parse3(microfrontendsJsonContent);
+      const microfrontendsJson = parse2(microfrontendsJsonContent);
       if (isMainConfig(microfrontendsJson) && microfrontendsJson.applications[applicationName]) {
         matchingPaths.push(microfrontendsJsonPath);
       }
@@ -2036,7 +914,7 @@ ${matchingPaths.join("\n  \u2022 ")}`
       );
     }
     const [packageJsonPath] = matchingPaths;
-    return dirname3(packageJsonPath);
+    return dirname2(packageJsonPath);
   } catch (error) {
     return null;
   }
@@ -2056,25 +934,25 @@ function findDefaultMicrofrontendsPackage(opts) {
   return result;
 }
 
-// src/config-v2/microfrontends/utils/is-monorepo.ts
-import fs4 from "node:fs";
-import path4 from "node:path";
+// src/config/microfrontends/utils/is-monorepo.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
 function isMonorepo({
   repositoryRoot
 }) {
   try {
-    if (fs4.existsSync(path4.join(repositoryRoot, "pnpm-workspace.yaml"))) {
+    if (fs2.existsSync(path2.join(repositoryRoot, "pnpm-workspace.yaml"))) {
       return true;
     }
-    if (fs4.existsSync(path4.join(repositoryRoot, "vlt-workspaces.json"))) {
+    if (fs2.existsSync(path2.join(repositoryRoot, "vlt-workspaces.json"))) {
       return true;
     }
-    const packageJsonPath = path4.join(repositoryRoot, "package.json");
-    if (!fs4.existsSync(packageJsonPath)) {
+    const packageJsonPath = path2.join(repositoryRoot, "package.json");
+    if (!fs2.existsSync(packageJsonPath)) {
       return false;
     }
     const packageJson = JSON.parse(
-      fs4.readFileSync(packageJsonPath, "utf-8")
+      fs2.readFileSync(packageJsonPath, "utf-8")
     );
     return packageJson.workspaces !== void 0;
   } catch (error) {
@@ -2083,43 +961,67 @@ function isMonorepo({
   }
 }
 
-// src/config-v2/microfrontends/utils/find-package-root.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
+// src/config/microfrontends/utils/find-package-root.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
 var PACKAGE_JSON = "package.json";
 function findPackageRoot(startDir) {
   let currentDir = startDir || process.cwd();
-  while (currentDir !== path5.parse(currentDir).root) {
-    const pkgJsonPath = path5.join(currentDir, PACKAGE_JSON);
-    if (fs5.existsSync(pkgJsonPath)) {
+  while (currentDir !== path3.parse(currentDir).root) {
+    const pkgJsonPath = path3.join(currentDir, PACKAGE_JSON);
+    if (fs3.existsSync(pkgJsonPath)) {
       return currentDir;
     }
-    currentDir = path5.dirname(currentDir);
+    currentDir = path3.dirname(currentDir);
   }
   throw new Error(
     "Package root not found. Specify the root of the package with the `package.root` option."
   );
 }
 
-// src/config-v2/microfrontends/utils/find-config.ts
-import fs6 from "node:fs";
+// src/config/microfrontends/utils/find-config.ts
+import fs4 from "node:fs";
 import { join } from "node:path";
 function findConfig({ dir }) {
   for (const filename of CONFIGURATION_FILENAMES) {
     const maybeConfig = join(dir, filename);
-    if (fs6.existsSync(maybeConfig)) {
+    if (fs4.existsSync(maybeConfig)) {
       return maybeConfig;
     }
   }
   return null;
 }
 
-// src/config-v2/microfrontends/server/validation.ts
-import { parse as parse4 } from "jsonc-parser";
-import { Ajv as Ajv2 } from "ajv";
+// src/config/microfrontends/server/utils/get-output-file-path.ts
+import path4 from "node:path";
+
+// src/config/microfrontends/server/constants.ts
+var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
+var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
+
+// src/utils/is-vercel.ts
+function isVercel() {
+  return process.env.VERCEL === "1";
+}
+
+// src/config/microfrontends/server/utils/get-output-file-path.ts
+function getOutputFilePath() {
+  if (isVercel()) {
+    return path4.join(
+      ".vercel",
+      MFE_CONFIG_DEFAULT_FILE_PATH,
+      MFE_CONFIG_DEFAULT_FILE_NAME
+    );
+  }
+  return path4.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+}
+
+// src/config/microfrontends/server/validation.ts
+import { parse as parse3 } from "jsonc-parser";
+import { Ajv } from "ajv";
 
-// schema/schema-v2.json
-var schema_v2_default = {
+// schema/schema.json
+var schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
   $ref: "#/definitions/Config",
   definitions: {
@@ -2158,7 +1060,8 @@ var schema_v2_default = {
           description: "Mapping of application names to the routes that they host. Only needs to be defined in the application that owns the primary microfrontend domain"
         }
       },
-      required: ["applications", "version"]
+      required: ["applications", "version"],
+      additionalProperties: false
     },
     Options: {
       type: "object",
@@ -2171,7 +1074,8 @@ var schema_v2_default = {
           $ref: "#/definitions/LocalProxyOptions",
           description: "Options for local proxy."
         }
-      }
+      },
+      additionalProperties: false
     },
     VercelOptions: {
       type: "object",
@@ -2184,7 +1088,8 @@ var schema_v2_default = {
           type: "boolean",
           description: "If you want to disable the overrides for the site. For example, if you are managing rewrites between applications externally, you may wish to disable the overrides on the toolbar as they will have no effect."
         }
-      }
+      },
+      additionalProperties: false
     },
     LocalProxyOptions: {
       type: "object",
@@ -2193,7 +1098,8 @@ var schema_v2_default = {
           type: "number",
           description: "The port number used by the local proxy server.\n\nThe default is `3024`."
         }
-      }
+      },
+      additionalProperties: false
     },
     Application: {
       anyOf: [
@@ -2218,7 +1124,8 @@ var schema_v2_default = {
           $ref: "#/definitions/HostConfig"
         }
       },
-      required: ["production"]
+      required: ["production"],
+      additionalProperties: false
     },
     Vercel: {
       type: "object",
@@ -2228,7 +1135,8 @@ var schema_v2_default = {
           description: "Vercel project ID"
         }
       },
-      required: ["projectId"]
+      required: ["projectId"],
+      additionalProperties: false
     },
     Development: {
       type: "object",
@@ -2244,10 +1152,12 @@ var schema_v2_default = {
           type: "string",
           description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
         }
-      }
+      },
+      additionalProperties: false
     },
     LocalHostConfig: {
       type: "object",
+      additionalProperties: false,
       properties: {
         host: {
           type: "string",
@@ -2281,7 +1191,8 @@ var schema_v2_default = {
           description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS."
         }
       },
-      required: ["host"]
+      required: ["host"],
+      additionalProperties: false
     },
     ChildApplication: {
       type: "object",
@@ -2300,7 +1211,8 @@ var schema_v2_default = {
           $ref: "#/definitions/HostConfig"
         }
       },
-      required: ["routing"]
+      required: ["routing"],
+      additionalProperties: false
     },
     Routing: {
       type: "array",
@@ -2326,7 +1238,8 @@ var schema_v2_default = {
           }
         }
       },
-      required: ["paths"]
+      required: ["paths"],
+      additionalProperties: false
     },
     ApplicationRouting: {
       type: "object",
@@ -2359,19 +1272,20 @@ var schema_v2_default = {
           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"]
+      required: ["partOf", "version"],
+      additionalProperties: false
     }
   }
 };
 
-// src/config-v2/schema/utils/load.ts
-var SCHEMA2 = schema_v2_default;
+// src/config/schema/utils/load.ts
+var SCHEMA = schema_default;
 
-// src/config-v2/microfrontends/server/validation.ts
-function validateSchema2(configString) {
-  const parsedConfig = parse4(configString);
-  const ajv = new Ajv2();
-  const validate = ajv.compile(SCHEMA2);
+// src/config/microfrontends/server/validation.ts
+function validateSchema(configString) {
+  const parsedConfig = parse3(configString);
+  const ajv = new Ajv();
+  const validate = ajv.compile(SCHEMA);
   const isValid = validate(parsedConfig);
   if (!isValid) {
     throw new MicrofrontendError(
@@ -2382,7 +1296,7 @@ function validateSchema2(configString) {
   return parsedConfig;
 }
 
-// src/config-v2/microfrontends/server/index.ts
+// src/config/microfrontends/server/index.ts
 var MicrofrontendsServer = class extends Microfrontends {
   /**
    * Writes the configuration to a file.
@@ -2391,8 +1305,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    fs7.mkdirSync(dirname4(outputPath), { recursive: true });
-    fs7.writeFileSync(
+    fs5.mkdirSync(dirname3(outputPath), { recursive: true });
+    fs5.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -2425,7 +1339,7 @@ var MicrofrontendsServer = class extends Microfrontends {
         meta
       });
     }
-    throw new MicrofrontendError2(
+    throw new MicrofrontendError(
       "Invalid config: must be a string or an object",
       { type: "config", subtype: "does_not_match_schema" }
     );
@@ -2449,7 +1363,7 @@ var MicrofrontendsServer = class extends Microfrontends {
    */
   static validate(config) {
     if (typeof config === "string") {
-      const c = validateSchema2(config);
+      const c = validateSchema(config);
       return c;
     }
     return config;
@@ -2480,7 +1394,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       const packageRoot = findPackageRoot(directory);
       const packageJsonPath = join2(packageRoot, "package.json");
       const packageJson = JSON.parse(
-        fs7.readFileSync(packageJsonPath, "utf-8")
+        fs5.readFileSync(packageJsonPath, "utf-8")
       );
       if (!packageJson.name) {
         throw new Error(`No name found in package.json at ${packageJsonPath}`);
@@ -2514,7 +1428,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       }
       throw new Error("Unable to infer");
     } catch (e) {
-      throw new MicrofrontendError2(
+      throw new MicrofrontendError(
         "Unable to infer microfrontends configuration",
         { type: "config", subtype: "inference_failed" }
       );
@@ -2530,7 +1444,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     options
   }) {
     try {
-      const configJson = fs7.readFileSync(filePath, "utf-8");
+      const configJson = fs5.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
       if (!isMainConfig(config) && (options == null ? void 0 : options.resolveMainConfig)) {
         const repositoryRoot = findRepositoryRoot();
@@ -2541,14 +1455,14 @@ var MicrofrontendsServer = class extends Microfrontends {
             name: config.partOf
           });
           if (!packagePath) {
-            throw new MicrofrontendError2(
+            throw new MicrofrontendError(
               `Could not find default application "${config.partOf}" in the repository`,
               { type: "config", subtype: "not_found" }
             );
           }
           const maybeConfig = findConfig({ dir: packagePath });
           if (!maybeConfig) {
-            throw new MicrofrontendError2(
+            throw new MicrofrontendError(
               `Could not find microfrontends configuration in ${packagePath}`,
               { type: "config", subtype: "not_found" }
             );
@@ -2565,7 +1479,7 @@ var MicrofrontendsServer = class extends Microfrontends {
         meta
       });
     } catch (e) {
-      throw MicrofrontendError2.handle(e, {
+      throw MicrofrontendError.handle(e, {
         fileName: filePath
       });
     }
@@ -2578,10 +1492,10 @@ var MicrofrontendsServer = class extends Microfrontends {
     overrides
   }) {
     try {
-      const config = fs7.readFileSync(filePath, "utf-8");
+      const config = fs5.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
       if (!isMainConfig(validatedConfig)) {
-        throw new MicrofrontendError2(
+        throw new MicrofrontendError(
           `${filePath} is not a main microfrontend config`,
           {
             type: "config",
@@ -2591,7 +1505,7 @@ var MicrofrontendsServer = class extends Microfrontends {
       }
       const [defaultApplication] = Object.entries(validatedConfig.applications).filter(([, app]) => isDefaultApp(app)).map(([name]) => name);
       if (!defaultApplication) {
-        throw new MicrofrontendError2(
+        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" }
         );
@@ -2602,7 +1516,7 @@ var MicrofrontendsServer = class extends Microfrontends {
         meta: { fromApp: defaultApplication }
       });
     } catch (e) {
-      throw MicrofrontendError2.handle(e, {
+      throw MicrofrontendError.handle(e, {
         fileName: filePath
       });
     }
@@ -2612,9 +1526,9 @@ var MicrofrontendsServer = class extends Microfrontends {
 // src/utils/mfe-port.ts
 function mfePort(packageDir) {
   const { name: appName, version } = getPackageJson(packageDir);
-  const result = loadV2({ packageDir, appName }) || loadV1({ packageDir, appName });
+  const result = loadConfig({ packageDir, appName });
   if (!result) {
-    throw new MicrofrontendError2(
+    throw new MicrofrontendError(
       `Unable to determine configured port for ${appName}`,
       { type: "config", subtype: "not_found" }
     );
@@ -2627,10 +1541,10 @@ function mfePort(packageDir) {
   };
 }
 function getPackageJson(packageDir) {
-  const filePath = path6.join(packageDir, "package.json");
-  return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+  const filePath = path5.join(packageDir, "package.json");
+  return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
 }
-function loadV2({
+function loadConfig({
   packageDir,
   appName
 }) {
@@ -2648,21 +1562,6 @@ function loadV2({
   const port = app.development.local.port;
   return { port };
 }
-function loadV1({
-  packageDir,
-  appName
-}) {
-  const filePath = path6.join(packageDir, "micro-frontends.jsonc");
-  let config;
-  try {
-    config = MicrofrontendConfig.fromFile({ filePath });
-  } catch (e) {
-    return void 0;
-  }
-  const zone = config.getZone(appName);
-  const port = zone.development.local.port;
-  return { port };
-}
 export {
   mfePort
 };