@vercel/microfrontends 2.2.0 → 2.2.2

package/dist/utils/mfe-port.js

@@ -1,43 +1,32 @@
 // src/utils/mfe-port.ts
-import path6 from "node:path";
 import fs7 from "node:fs";
+import path6 from "node:path";
 
 // src/config/microfrontends/server/index.ts
 import fs6 from "node:fs";
-import { dirname as dirname2, join as join2, resolve } from "node:path";
-
-// src/config/overrides/constants.ts
-var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
-var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
+import { dirname as dirname2, join as join3, resolve } from "node:path";
 
-// src/config/overrides/is-override-cookie.ts
-function isOverrideCookie(cookie) {
-  return Boolean(cookie.name?.startsWith(OVERRIDES_COOKIE_PREFIX));
+// src/bin/logger.ts
+function debug(...args) {
+  if (process.env.MFE_DEBUG) {
+    console.log(...args);
+  }
 }
-
-// src/config/overrides/get-override-from-cookie.ts
-function getOverrideFromCookie(cookie) {
-  if (!isOverrideCookie(cookie) || !cookie.value)
-    return;
-  return {
-    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
-    host: cookie.value
-  };
+function info(...args) {
+  console.log(...args);
 }
-
-// src/config/overrides/parse-overrides.ts
-function parseOverrides(cookies) {
-  const overridesConfig = { applications: {} };
-  cookies.forEach((cookie) => {
-    const override = getOverrideFromCookie(cookie);
-    if (!override)
-      return;
-    overridesConfig.applications[override.application] = {
-      environment: { host: override.host }
-    };
-  });
-  return overridesConfig;
+function warn(...args) {
+  console.warn(...args);
+}
+function error(...args) {
+  console.error(...args);
 }
+var logger = {
+  debug,
+  info,
+  warn,
+  error
+};
 
 // src/config/errors.ts
 var MicrofrontendError = class extends Error {
@@ -131,277 +120,47 @@ var MicrofrontendError = class extends Error {
   }
 };
 
-// src/config/microfrontends-config/utils/get-config-from-env.ts
-function getConfigStringFromEnv() {
-  const config = process.env.MFE_CONFIG;
-  if (!config) {
-    throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
-      type: "config",
-      subtype: "not_found_in_env"
-    });
-  }
-  return config;
-}
-
-// src/config/schema/utils/is-default-app.ts
-function isDefaultApp(a) {
-  return !("routing" in a);
-}
-
-// src/config/microfrontends/utils/find-repository-root.ts
-import fs from "node:fs";
-import path from "node:path";
-var GIT_DIRECTORY = ".git";
-function hasGitDirectory(dir) {
-  const gitPath = path.join(dir, GIT_DIRECTORY);
-  return fs.existsSync(gitPath) && fs.statSync(gitPath).isDirectory();
-}
-function hasPnpmWorkspaces(dir) {
-  return fs.existsSync(path.join(dir, "pnpm-workspace.yaml"));
-}
-function hasPackageJson(dir) {
-  return fs.existsSync(path.join(dir, "package.json"));
-}
-function findRepositoryRoot(startDir) {
-  if (process.env.NX_WORKSPACE_ROOT) {
-    return process.env.NX_WORKSPACE_ROOT;
-  }
-  let currentDir = startDir || process.cwd();
-  let lastPackageJsonDir = null;
-  while (currentDir !== path.parse(currentDir).root) {
-    if (hasGitDirectory(currentDir) || hasPnpmWorkspaces(currentDir)) {
-      return currentDir;
-    }
-    if (hasPackageJson(currentDir)) {
-      lastPackageJsonDir = currentDir;
-    }
-    currentDir = path.dirname(currentDir);
-  }
-  if (lastPackageJsonDir) {
-    return lastPackageJsonDir;
-  }
-  throw new Error(
-    `Could not find the root of the repository for ${startDir}. Please ensure that the directory is part of a Git repository. If you suspect that this should work, please file an issue to the Vercel team.`
-  );
-}
-
-// src/config/microfrontends/utils/infer-microfrontends-location.ts
-import { dirname } from "node:path";
-import { readFileSync } from "node:fs";
+// src/config/microfrontends-config/isomorphic/index.ts
 import { parse } from "jsonc-parser";
-import fg from "fast-glob";
-
-// src/config/microfrontends/utils/get-config-file-name.ts
-var DEFAULT_CONFIGURATION_FILENAMES = [
-  "microfrontends.json",
-  "microfrontends.jsonc"
-];
-function getPossibleConfigurationFilenames({
-  customConfigFilename
-}) {
-  if (customConfigFilename) {
-    if (!customConfigFilename.endsWith(".json") && !customConfigFilename.endsWith(".jsonc")) {
-      throw new Error(
-        `Found VC_MICROFRONTENDS_CONFIG_FILE_NAME but the name is invalid. Received: ${customConfigFilename}. The file name must end with '.json' or '.jsonc'. It's also possible for the env var to include the path, eg microfrontends-dev.json or /path/to/microfrontends-dev.json.`
-      );
-    }
-    return Array.from(
-      /* @__PURE__ */ new Set([customConfigFilename, ...DEFAULT_CONFIGURATION_FILENAMES])
-    );
-  }
-  return DEFAULT_CONFIGURATION_FILENAMES;
-}
 
-// src/config/microfrontends/utils/infer-microfrontends-location.ts
-var configCache = {};
-function findPackageWithMicrofrontendsConfig({
-  repositoryRoot,
-  applicationContext,
-  customConfigFilename
-}) {
-  const applicationName = applicationContext.name;
-  try {
-    const microfrontendsJsonPaths = fg.globSync(
-      `**/{${getPossibleConfigurationFilenames({ customConfigFilename }).join(",")}}`,
-      {
-        cwd: repositoryRoot,
-        absolute: true,
-        onlyFiles: true,
-        followSymbolicLinks: false,
-        ignore: ["**/node_modules/**", "**/.git/**"]
-      }
-    );
-    const matchingPaths = [];
-    for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
-      try {
-        const microfrontendsJsonContent = readFileSync(
-          microfrontendsJsonPath,
-          "utf-8"
-        );
-        const microfrontendsJson = parse(microfrontendsJsonContent);
-        if (microfrontendsJson.applications[applicationName]) {
-          matchingPaths.push(microfrontendsJsonPath);
-        } else {
-          for (const [_, app] of Object.entries(
-            microfrontendsJson.applications
-          )) {
-            if (app.packageName === applicationName) {
-              matchingPaths.push(microfrontendsJsonPath);
-            }
-          }
-        }
-      } catch (error2) {
-      }
-    }
-    if (matchingPaths.length > 1) {
-      throw new MicrofrontendError(
-        `Found multiple \`microfrontends.json\` files in the repository referencing the application "${applicationName}", but only one is allowed.
-${matchingPaths.join("\n  \u2022 ")}`,
-        { type: "config", subtype: "inference_failed" }
-      );
-    }
-    if (matchingPaths.length === 0) {
-      let additionalErrorMessage = "";
-      if (microfrontendsJsonPaths.length > 0) {
-        if (!applicationContext.projectName) {
-          additionalErrorMessage = `
-
-If the name in package.json (${applicationContext.packageJsonName}) differs from your Vercel Project name, set the \`packageName\` field for the application in \`microfrontends.json\` to ensure that the configuration can be found locally.`;
-        } else {
-          additionalErrorMessage = `
-
-Names of applications in \`microfrontends.json\` must match the Vercel Project name (${applicationContext.projectName}).`;
-        }
-      }
-      throw new MicrofrontendError(
-        `Could not find a \`microfrontends.json\` file in the repository that contains the "${applicationName}" application.${additionalErrorMessage}
-
-If your Vercel Microfrontends configuration is not in this repository, you can use the Vercel CLI to pull the Vercel Microfrontends configuration using the "vercel microfrontends pull" command, or you can specify the path manually using the VC_MICROFRONTENDS_CONFIG environment variable.
-
-If your Vercel Microfrontends configuration has a custom name, ensure the VC_MICROFRONTENDS_CONFIG_FILE_NAME environment variable is set, you can pull the vercel project environment variables using the "vercel env pull" command.
-
-If you suspect this is thrown in error, please reach out to the Vercel team.`,
-        { type: "config", subtype: "inference_failed" }
-      );
-    }
-    const [packageJsonPath] = matchingPaths;
-    return dirname(packageJsonPath);
-  } catch (error2) {
-    if (error2 instanceof MicrofrontendError) {
-      throw error2;
-    }
-    return null;
-  }
-}
-function inferMicrofrontendsLocation(opts) {
-  const cacheKey = `${opts.repositoryRoot}-${opts.applicationContext.name}${opts.customConfigFilename ? `-${opts.customConfigFilename}` : ""}`;
-  if (configCache[cacheKey]) {
-    return configCache[cacheKey];
-  }
-  const result = findPackageWithMicrofrontendsConfig(opts);
-  if (!result) {
-    throw new MicrofrontendError(
-      `Could not infer the location of the \`microfrontends.json\` file for application "${opts.applicationContext.name}" starting in directory "${opts.repositoryRoot}".`,
-      { type: "config", subtype: "inference_failed" }
-    );
-  }
-  configCache[cacheKey] = result;
-  return result;
-}
-
-// src/config/microfrontends/utils/is-monorepo.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+// src/config/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
 
-// src/bin/logger.ts
-function debug(...args) {
-  if (process.env.MFE_DEBUG) {
-    console.log(...args);
-  }
-}
-function info(...args) {
-  console.log(...args);
-}
-function warn(...args) {
-  console.warn(...args);
-}
-function error(...args) {
-  console.error(...args);
+// src/config/overrides/is-override-cookie.ts
+function isOverrideCookie(cookie) {
+  return Boolean(cookie.name?.startsWith(OVERRIDES_COOKIE_PREFIX));
 }
-var logger = {
-  debug,
-  info,
-  warn,
-  error
-};
 
-// src/config/microfrontends/utils/is-monorepo.ts
-function isMonorepo({
-  repositoryRoot
-}) {
-  try {
-    if (fs2.existsSync(path2.join(repositoryRoot, "pnpm-workspace.yaml"))) {
-      return true;
-    }
-    if (fs2.existsSync(path2.join(repositoryRoot, "vlt-workspaces.json"))) {
-      return true;
-    }
-    if (process.env.NX_WORKSPACE_ROOT === path2.resolve(repositoryRoot)) {
-      return true;
-    }
-    const packageJsonPath = path2.join(repositoryRoot, "package.json");
-    if (!fs2.existsSync(packageJsonPath)) {
-      return false;
-    }
-    const packageJson = JSON.parse(
-      fs2.readFileSync(packageJsonPath, "utf-8")
-    );
-    return packageJson.workspaces !== void 0;
-  } catch (error2) {
-    logger.error("Error determining if repository is a monorepo", error2);
-    return false;
-  }
+// src/config/overrides/get-override-from-cookie.ts
+function getOverrideFromCookie(cookie) {
+  if (!isOverrideCookie(cookie) || !cookie.value)
+    return;
+  return {
+    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
+    host: cookie.value
+  };
 }
 
-// src/config/microfrontends/utils/find-package-root.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
-var PACKAGE_JSON = "package.json";
-function findPackageRoot(startDir) {
-  let currentDir = startDir || process.cwd();
-  while (currentDir !== path3.parse(currentDir).root) {
-    const pkgJsonPath = path3.join(currentDir, PACKAGE_JSON);
-    if (fs3.existsSync(pkgJsonPath)) {
-      return currentDir;
-    }
-    currentDir = path3.dirname(currentDir);
-  }
-  throw new Error(
-    `The root of the package that contains the \`package.json\` file for the \`${startDir}\` directory could not be found.`
-  );
+// src/config/overrides/parse-overrides.ts
+function parseOverrides(cookies) {
+  const overridesConfig = { applications: {} };
+  cookies.forEach((cookie) => {
+    const override = getOverrideFromCookie(cookie);
+    if (!override)
+      return;
+    overridesConfig.applications[override.application] = {
+      environment: { host: override.host }
+    };
+  });
+  return overridesConfig;
 }
 
-// src/config/microfrontends/utils/find-config.ts
-import fs4 from "node:fs";
-import { join } from "node:path";
-function findConfig({
-  dir,
-  customConfigFilename
-}) {
-  for (const filename of getPossibleConfigurationFilenames({
-    customConfigFilename
-  })) {
-    const maybeConfig = join(dir, filename);
-    if (fs4.existsSync(maybeConfig)) {
-      return maybeConfig;
-    }
-  }
-  return null;
+// src/config/schema/utils/is-default-app.ts
+function isDefaultApp(a) {
+  return !("routing" in a);
 }
 
-// src/config/microfrontends-config/isomorphic/index.ts
-import { parse as parse2 } from "jsonc-parser";
-
 // src/config/microfrontends-config/client/index.ts
 import { pathToRegexp } from "path-to-regexp";
 var regexpCache = /* @__PURE__ */ new Map();
@@ -450,58 +209,235 @@ var MicrofrontendConfigClient = class {
     }
     this.applications = config.applications;
   }
-  /**
-   * Create a new `MicrofrontendConfigClient` from a JSON string.
-   * Config must be passed in to remain framework agnostic
-   */
-  static fromEnv(config) {
-    if (!config) {
-      throw new Error(
-        "Could not construct MicrofrontendConfigClient: configuration is empty or undefined. Did you set up your application with `withMicrofrontends`? Is the local proxy running and this application is being accessed via the proxy port? See https://vercel.com/docs/microfrontends/local-development#setting-up-microfrontends-proxy"
-      );
-    }
-    return new MicrofrontendConfigClient(JSON.parse(config));
+  /**
+   * Create a new `MicrofrontendConfigClient` from a JSON string.
+   * Config must be passed in to remain framework agnostic
+   */
+  static fromEnv(config) {
+    if (!config) {
+      throw new Error(
+        "Could not construct MicrofrontendConfigClient: configuration is empty or undefined. Did you set up your application with `withMicrofrontends`? Is the local proxy running and this application is being accessed via the proxy port? See https://vercel.com/docs/microfrontends/local-development#setting-up-microfrontends-proxy"
+      );
+    }
+    return new MicrofrontendConfigClient(JSON.parse(config));
+  }
+  isEqual(other) {
+    return this === other || JSON.stringify(this.applications) === JSON.stringify(other.applications);
+  }
+  getApplicationNameForPath(path7) {
+    if (!path7.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path7]) {
+      return this.pathCache[path7];
+    }
+    const pathname = new URL(path7, "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 = getRegexp(childPath);
+            if (regexp.test(pathname)) {
+              this.pathCache[path7] = name;
+              return name;
+            }
+          }
+        }
+      }
+    }
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path7] = defaultApplication[0];
+    return defaultApplication[0];
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config/microfrontends-config/utils/get-config-from-env.ts
+function getConfigStringFromEnv() {
+  const config = process.env.MFE_CONFIG;
+  if (!config) {
+    throw new MicrofrontendError(`Missing "MFE_CONFIG" in environment.`, {
+      type: "config",
+      subtype: "not_found_in_env"
+    });
+  }
+  return config;
+}
+
+// src/config/microfrontends-config/isomorphic/constants.ts
+var DEFAULT_LOCAL_PROXY_PORT = 3024;
+var MFE_APP_PORT_ENV = "MFE_APP_PORT";
+var MFE_LOCAL_PROXY_PORT_ENV = "MFE_LOCAL_PROXY_PORT";
+
+// src/config/microfrontends-config/isomorphic/utils/generate-port.ts
+function generatePortFromName({
+  name,
+  minPort = 3e3,
+  maxPort = 8e3
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate a port");
+  }
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = (hash << 5) - hash + name.charCodeAt(i);
+    hash |= 0;
+  }
+  hash = Math.abs(hash);
+  const range = maxPort - minPort;
+  const port = minPort + hash % range;
+  return port;
+}
+
+// src/config/microfrontends-config/isomorphic/host.ts
+var Host = class {
+  constructor(hostConfig, options) {
+    if (typeof hostConfig === "string") {
+      ({
+        protocol: this.protocol,
+        host: this.host,
+        port: this.port
+      } = Host.parseUrl(hostConfig));
+    } else {
+      const { protocol = "https", host, port } = hostConfig;
+      this.protocol = protocol;
+      this.host = host;
+      this.port = port;
+    }
+    this.local = options?.isLocal;
+  }
+  static parseUrl(url, defaultProtocol = "https") {
+    let hostToParse = url;
+    if (!/^https?:\/\//.exec(hostToParse)) {
+      hostToParse = `${defaultProtocol}://${hostToParse}`;
+    }
+    const parsed = new URL(hostToParse);
+    if (!parsed.hostname) {
+      throw new Error(Host.getMicrofrontendsError(url, "requires a host"));
+    }
+    if (parsed.hash) {
+      throw new Error(
+        Host.getMicrofrontendsError(url, "cannot have a fragment")
+      );
+    }
+    if (parsed.username || parsed.password) {
+      throw new Error(
+        Host.getMicrofrontendsError(
+          url,
+          "cannot have authentication credentials (username and/or password)"
+        )
+      );
+    }
+    if (parsed.pathname !== "/") {
+      throw new Error(Host.getMicrofrontendsError(url, "cannot have a path"));
+    }
+    if (parsed.search) {
+      throw new Error(
+        Host.getMicrofrontendsError(url, "cannot have query parameters")
+      );
+    }
+    const protocol = parsed.protocol.slice(0, -1);
+    return {
+      protocol,
+      host: parsed.hostname,
+      port: parsed.port ? Number.parseInt(parsed.port, 10) : void 0
+    };
+  }
+  static getMicrofrontendsError(url, message) {
+    return `Microfrontends configuration error: the URL ${url} in your microfrontends.json ${message}.`;
+  }
+  isLocal() {
+    return this.local || this.host === "localhost" || this.host === "127.0.0.1";
+  }
+  toString() {
+    const url = this.toUrl();
+    return url.toString().replace(/\/$/, "");
   }
-  isEqual(other) {
-    return this === other || JSON.stringify(this.applications) === JSON.stringify(other.applications);
+  toUrl() {
+    const url = `${this.protocol}://${this.host}${this.port ? `:${this.port}` : ""}`;
+    return new URL(url);
   }
-  getApplicationNameForPath(path7) {
-    if (!path7.startsWith("/")) {
-      throw new Error(`Path must start with a /`);
-    }
-    if (this.pathCache[path7]) {
-      return this.pathCache[path7];
-    }
-    const pathname = new URL(path7, "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 = getRegexp(childPath);
-            if (regexp.test(pathname)) {
-              this.pathCache[path7] = name;
-              return name;
-            }
-          }
-        }
+};
+var LocalHost = class extends Host {
+  constructor({
+    appName,
+    local
+  }) {
+    const portOverride = process.env[MFE_APP_PORT_ENV];
+    if (portOverride) {
+      const overridePort = Number.parseInt(portOverride, 10);
+      if (!Number.isNaN(overridePort) && overridePort > 0 && overridePort < 65536) {
+        super({
+          protocol: "http",
+          host: "localhost",
+          port: overridePort
+        });
+        return;
       }
     }
-    const defaultApplication = Object.entries(this.applications).find(
-      ([, application]) => application.default
-    );
-    if (!defaultApplication) {
-      return null;
+    let protocol;
+    let host;
+    let port;
+    if (typeof local === "number") {
+      port = local;
+    } else if (typeof local === "string") {
+      if (/^\d+$/.test(local)) {
+        port = Number.parseInt(local, 10);
+      } else {
+        const parsed = Host.parseUrl(local, "http");
+        protocol = parsed.protocol;
+        host = parsed.host;
+        port = parsed.port;
+      }
+    } else if (local) {
+      protocol = local.protocol;
+      host = local.host;
+      port = local.port;
     }
-    this.pathCache[path7] = defaultApplication[0];
-    return defaultApplication[0];
-  }
-  serialize() {
-    return this.serialized;
+    super({
+      protocol: protocol ?? "http",
+      host: host ?? "localhost",
+      port: port ?? generatePortFromName({ name: appName })
+    });
   }
 };
 
+// src/config/microfrontends-config/isomorphic/utils/hash-application-name.ts
+import md5 from "md5";
+function hashApplicationName(name) {
+  if (!name) {
+    throw new Error("Application name is required to generate hash");
+  }
+  return md5(name).substring(0, 6).padStart(6, "0");
+}
+
+// src/config/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
+var PREFIX = "vc-ap";
+function generateAssetPrefixFromName({
+  name
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate an asset prefix");
+  }
+  return `${PREFIX}-${hashApplicationName(name)}`;
+}
+
+// src/config/microfrontends-config/isomorphic/utils/generate-automation-bypass-env-var-name.ts
+function generateAutomationBypassEnvVarName({
+  name
+}) {
+  return `AUTOMATION_BYPASS_${name.toUpperCase().replace(/[^a-zA-Z0-9]/g, "_")}`;
+}
+
 // src/config/microfrontends-config/isomorphic/validation.ts
-import { pathToRegexp as pathToRegexp2, parse as parsePathRegexp } from "path-to-regexp";
+import { parse as parsePathRegexp, pathToRegexp as pathToRegexp2 } from "path-to-regexp";
 var LIST_FORMATTER = new Intl.ListFormat("en", {
   style: "long",
   type: "conjunction"
@@ -681,154 +617,6 @@ var validateConfigDefaultApplication = (applicationConfigsById) => {
   }
 };
 
-// src/config/microfrontends-config/isomorphic/utils/hash-application-name.ts
-import md5 from "md5";
-function hashApplicationName(name) {
-  if (!name) {
-    throw new Error("Application name is required to generate hash");
-  }
-  return md5(name).substring(0, 6).padStart(6, "0");
-}
-
-// src/config/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
-var PREFIX = "vc-ap";
-function generateAssetPrefixFromName({
-  name
-}) {
-  if (!name) {
-    throw new Error("Name is required to generate an asset prefix");
-  }
-  return `${PREFIX}-${hashApplicationName(name)}`;
-}
-
-// src/config/microfrontends-config/isomorphic/utils/generate-port.ts
-function generatePortFromName({
-  name,
-  minPort = 3e3,
-  maxPort = 8e3
-}) {
-  if (!name) {
-    throw new Error("Name is required to generate a port");
-  }
-  let hash = 0;
-  for (let i = 0; i < name.length; i++) {
-    hash = (hash << 5) - hash + name.charCodeAt(i);
-    hash |= 0;
-  }
-  hash = Math.abs(hash);
-  const range = maxPort - minPort;
-  const port = minPort + hash % range;
-  return port;
-}
-
-// src/config/microfrontends-config/isomorphic/host.ts
-var Host = class {
-  constructor(hostConfig, options) {
-    if (typeof hostConfig === "string") {
-      ({
-        protocol: this.protocol,
-        host: this.host,
-        port: this.port
-      } = Host.parseUrl(hostConfig));
-    } else {
-      const { protocol = "https", host, port } = hostConfig;
-      this.protocol = protocol;
-      this.host = host;
-      this.port = port;
-    }
-    this.local = options?.isLocal;
-  }
-  static parseUrl(url, defaultProtocol = "https") {
-    let hostToParse = url;
-    if (!/^https?:\/\//.exec(hostToParse)) {
-      hostToParse = `${defaultProtocol}://${hostToParse}`;
-    }
-    const parsed = new URL(hostToParse);
-    if (!parsed.hostname) {
-      throw new Error(Host.getMicrofrontendsError(url, "requires a host"));
-    }
-    if (parsed.hash) {
-      throw new Error(
-        Host.getMicrofrontendsError(url, "cannot have a fragment")
-      );
-    }
-    if (parsed.username || parsed.password) {
-      throw new Error(
-        Host.getMicrofrontendsError(
-          url,
-          "cannot have authentication credentials (username and/or password)"
-        )
-      );
-    }
-    if (parsed.pathname !== "/") {
-      throw new Error(Host.getMicrofrontendsError(url, "cannot have a path"));
-    }
-    if (parsed.search) {
-      throw new Error(
-        Host.getMicrofrontendsError(url, "cannot have query parameters")
-      );
-    }
-    const protocol = parsed.protocol.slice(0, -1);
-    return {
-      protocol,
-      host: parsed.hostname,
-      port: parsed.port ? Number.parseInt(parsed.port) : void 0
-    };
-  }
-  static getMicrofrontendsError(url, message) {
-    return `Microfrontends configuration error: the URL ${url} in your microfrontends.json ${message}.`;
-  }
-  isLocal() {
-    return this.local || this.host === "localhost" || this.host === "127.0.0.1";
-  }
-  toString() {
-    const url = this.toUrl();
-    return url.toString().replace(/\/$/, "");
-  }
-  toUrl() {
-    const url = `${this.protocol}://${this.host}${this.port ? `:${this.port}` : ""}`;
-    return new URL(url);
-  }
-};
-var LocalHost = class extends Host {
-  constructor({
-    appName,
-    local
-  }) {
-    let protocol;
-    let host;
-    let port;
-    if (typeof local === "number") {
-      port = local;
-    } else if (typeof local === "string") {
-      if (/^\d+$/.test(local)) {
-        port = Number.parseInt(local);
-      } else {
-        const parsed = Host.parseUrl(local, "http");
-        protocol = parsed.protocol;
-        host = parsed.host;
-        port = parsed.port;
-      }
-    } else if (local) {
-      protocol = local.protocol;
-      host = local.host;
-      port = local.port;
-    }
-    super({
-      protocol: protocol ?? "http",
-      host: host ?? "localhost",
-      port: port ?? generatePortFromName({ name: appName })
-    });
-  }
-};
-
-// src/config/microfrontends-config/isomorphic/utils/generate-automation-bypass-env-var-name.ts
-function generateAutomationBypassEnvVarName({
-  name
-}) {
-  return `AUTOMATION_BYPASS_${name.toUpperCase().replace(/[^a-zA-Z0-9]/g, "_")}`;
-}
-
 // src/config/microfrontends-config/isomorphic/application.ts
 var Application = class {
   constructor(name, {
@@ -906,11 +694,8 @@ var ChildApplication = class extends Application {
   }
   static validate(name, app) {
     validateAppPaths(name, app);
-  }
-};
-
-// src/config/microfrontends-config/isomorphic/constants.ts
-var DEFAULT_LOCAL_PROXY_PORT = 3024;
+  }
+};
 
 // src/config/microfrontends-config/isomorphic/index.ts
 var MicrofrontendConfigIsomorphic = class {
@@ -955,7 +740,7 @@ var MicrofrontendConfigIsomorphic = class {
     };
   }
   static validate(config) {
-    const c = typeof config === "string" ? parse2(config) : config;
+    const c = typeof config === "string" ? parse(config) : config;
     validateConfigPaths(c.applications);
     validateConfigDefaultApplication(c.applications);
     return c;
@@ -964,7 +749,7 @@ var MicrofrontendConfigIsomorphic = class {
     cookies
   }) {
     return new MicrofrontendConfigIsomorphic({
-      config: parse2(getConfigStringFromEnv()),
+      config: parse(getConfigStringFromEnv()),
       overrides: parseOverrides(cookies ?? [])
     });
   }
@@ -1030,9 +815,17 @@ var MicrofrontendConfigIsomorphic = class {
     return this.defaultApplication;
   }
   /**
-   * Returns the configured port for the local proxy
+   * Returns the configured port for the local proxy.
+   * Can be overridden via MFE_LOCAL_PROXY_PORT environment variable.
    */
   getLocalProxyPort() {
+    const portOverride = process.env[MFE_LOCAL_PROXY_PORT_ENV];
+    if (portOverride) {
+      const port = Number.parseInt(portOverride, 10);
+      if (!Number.isNaN(port) && port > 0 && port < 65536) {
+        return port;
+      }
+    }
     return this.config.options?.localProxyPort ?? DEFAULT_LOCAL_PROXY_PORT;
   }
   toClientConfig(options) {
@@ -1070,32 +863,144 @@ var MicrofrontendConfigIsomorphic = class {
   }
 };
 
+// src/config/microfrontends/utils/find-config.ts
+import fs from "node:fs";
+import { join } from "node:path";
+
+// src/config/microfrontends/utils/get-config-file-name.ts
+var DEFAULT_CONFIGURATION_FILENAMES = [
+  "microfrontends.json",
+  "microfrontends.jsonc"
+];
+function getPossibleConfigurationFilenames({
+  customConfigFilename
+}) {
+  if (customConfigFilename) {
+    if (!customConfigFilename.endsWith(".json") && !customConfigFilename.endsWith(".jsonc")) {
+      throw new Error(
+        `Found VC_MICROFRONTENDS_CONFIG_FILE_NAME but the name is invalid. Received: ${customConfigFilename}. The file name must end with '.json' or '.jsonc'. It's also possible for the env var to include the path, eg microfrontends-dev.json or /path/to/microfrontends-dev.json.`
+      );
+    }
+    return Array.from(
+      /* @__PURE__ */ new Set([customConfigFilename, ...DEFAULT_CONFIGURATION_FILENAMES])
+    );
+  }
+  return DEFAULT_CONFIGURATION_FILENAMES;
+}
+
+// src/config/microfrontends/utils/find-config.ts
+function findConfig({
+  dir,
+  customConfigFilename
+}) {
+  for (const filename of getPossibleConfigurationFilenames({
+    customConfigFilename
+  })) {
+    const maybeConfig = join(dir, filename);
+    if (fs.existsSync(maybeConfig)) {
+      return maybeConfig;
+    }
+  }
+  return null;
+}
+
+// src/config/microfrontends/utils/find-package-root.ts
+import fs2 from "node:fs";
+import path from "node:path";
+var PACKAGE_JSON = "package.json";
+function findPackageRoot(startDir) {
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== path.parse(currentDir).root) {
+    const pkgJsonPath = path.join(currentDir, PACKAGE_JSON);
+    if (fs2.existsSync(pkgJsonPath)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  throw new Error(
+    `The root of the package that contains the \`package.json\` file for the \`${startDir}\` directory could not be found.`
+  );
+}
+
+// src/config/microfrontends/utils/find-repository-root.ts
+import fs3 from "node:fs";
+import path2 from "node:path";
+var GIT_DIRECTORY = ".git";
+function hasGitDirectory(dir) {
+  const gitPath = path2.join(dir, GIT_DIRECTORY);
+  return fs3.existsSync(gitPath) && fs3.statSync(gitPath).isDirectory();
+}
+function hasPnpmWorkspaces(dir) {
+  return fs3.existsSync(path2.join(dir, "pnpm-workspace.yaml"));
+}
+function hasPackageJson(dir) {
+  return fs3.existsSync(path2.join(dir, "package.json"));
+}
+function findRepositoryRoot(startDir) {
+  if (process.env.NX_WORKSPACE_ROOT) {
+    return process.env.NX_WORKSPACE_ROOT;
+  }
+  let currentDir = startDir || process.cwd();
+  let lastPackageJsonDir = null;
+  while (currentDir !== path2.parse(currentDir).root) {
+    if (hasGitDirectory(currentDir) || hasPnpmWorkspaces(currentDir)) {
+      return currentDir;
+    }
+    if (hasPackageJson(currentDir)) {
+      lastPackageJsonDir = currentDir;
+    }
+    currentDir = path2.dirname(currentDir);
+  }
+  if (lastPackageJsonDir) {
+    return lastPackageJsonDir;
+  }
+  throw new Error(
+    `Could not find the root of the repository for ${startDir}. Please ensure that the directory is part of a Git repository. If you suspect that this should work, please file an issue to the Vercel team.`
+  );
+}
+
 // src/config/microfrontends/utils/get-application-context.ts
-import fs5 from "node:fs";
-import path4 from "node:path";
+import fs4 from "node:fs";
+import path3 from "node:path";
 function getApplicationContext(opts) {
   if (opts?.appName) {
+    logger.debug(
+      "[MFE Config] Application name from appName parameter:",
+      opts.appName
+    );
     return { name: opts.appName };
   }
   if (process.env.VERCEL_PROJECT_NAME) {
+    logger.debug(
+      "[MFE Config] Application name from VERCEL_PROJECT_NAME:",
+      process.env.VERCEL_PROJECT_NAME
+    );
     return {
       name: process.env.VERCEL_PROJECT_NAME,
       projectName: process.env.VERCEL_PROJECT_NAME
     };
   }
   if (process.env.NX_TASK_TARGET_PROJECT) {
+    logger.debug(
+      "[MFE Config] Application name from NX_TASK_TARGET_PROJECT:",
+      process.env.NX_TASK_TARGET_PROJECT
+    );
     return {
       name: process.env.NX_TASK_TARGET_PROJECT,
       packageJsonName: process.env.NX_TASK_TARGET_PROJECT
     };
   }
   try {
-    const vercelProjectJsonPath = fs5.readFileSync(
-      path4.join(opts?.packageRoot || ".", ".vercel", "project.json"),
+    const vercelProjectJsonPath = fs4.readFileSync(
+      path3.join(opts?.packageRoot || ".", ".vercel", "project.json"),
       "utf-8"
     );
     const projectJson = JSON.parse(vercelProjectJsonPath);
     if (projectJson.projectName) {
+      logger.debug(
+        "[MFE Config] Application name from .vercel/project.json:",
+        projectJson.projectName
+      );
       return {
         name: projectJson.projectName,
         projectName: projectJson.projectName
@@ -1104,8 +1009,8 @@ function getApplicationContext(opts) {
   } catch (_) {
   }
   try {
-    const packageJsonString = fs5.readFileSync(
-      path4.join(opts?.packageRoot || ".", "package.json"),
+    const packageJsonString = fs4.readFileSync(
+      path3.join(opts?.packageRoot || ".", "package.json"),
       "utf-8"
     );
     const packageJson = JSON.parse(packageJsonString);
@@ -1119,6 +1024,10 @@ function getApplicationContext(opts) {
         }
       );
     }
+    logger.debug(
+      "[MFE Config] Application name from package.json:",
+      packageJson.name
+    );
     return { name: packageJson.name, packageJsonName: packageJson.name };
   } catch (err) {
     throw MicrofrontendError.handle(err, {
@@ -1127,6 +1036,209 @@ function getApplicationContext(opts) {
   }
 }
 
+// src/config/microfrontends/utils/infer-microfrontends-location.ts
+import { readFileSync, statSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import fg from "fast-glob";
+import { parse as parse2 } from "jsonc-parser";
+var configCache = {};
+function findPackageWithMicrofrontendsConfig({
+  repositoryRoot,
+  applicationContext,
+  customConfigFilename
+}) {
+  const applicationName = applicationContext.name;
+  logger.debug(
+    "[MFE Config] Searching repository for configs containing application:",
+    applicationName
+  );
+  try {
+    const microfrontendsJsonPaths = fg.globSync(
+      `**/{${getPossibleConfigurationFilenames({ customConfigFilename }).join(",")}}`,
+      {
+        cwd: repositoryRoot,
+        absolute: true,
+        onlyFiles: true,
+        followSymbolicLinks: false,
+        ignore: ["**/node_modules/**", "**/.git/**"]
+      }
+    );
+    logger.debug(
+      "[MFE Config] Found",
+      microfrontendsJsonPaths.length,
+      "config file(s) in repository"
+    );
+    const matchingPaths = [];
+    for (const microfrontendsJsonPath of microfrontendsJsonPaths) {
+      if (doesApplicationExistInConfig(microfrontendsJsonPath, applicationName)) {
+        matchingPaths.push(microfrontendsJsonPath);
+      }
+    }
+    logger.debug(
+      "[MFE Config] Total matching config files:",
+      matchingPaths.length
+    );
+    if (matchingPaths.length > 1) {
+      throw new MicrofrontendError(
+        `Found multiple \`microfrontends.json\` files in the repository referencing the application "${applicationName}", but only one is allowed.
+${matchingPaths.join("\n  \u2022 ")}`,
+        { type: "config", subtype: "inference_failed" }
+      );
+    }
+    if (matchingPaths.length === 0) {
+      if (repositoryRoot && doesMisplacedConfigExist(
+        repositoryRoot,
+        applicationName,
+        customConfigFilename
+      )) {
+        logger.debug(
+          "[MFE Config] Found misplaced config in wrong .vercel directory in repository"
+        );
+        const misplacedConfigPath = join2(
+          repositoryRoot,
+          ".vercel",
+          customConfigFilename || "microfrontends.json"
+        );
+        throw new MicrofrontendError(
+          `Unable to automatically infer the location of the \`microfrontends.json\` file.
+
+A microfrontends config was found in the \`.vercel\` directory at the repository root: ${misplacedConfigPath}
+However, in a monorepo, the config file should be placed in the \`.vercel\` directory in your application directory instead.
+
+To fix this:
+1. If using \`vercel link\`, run it with \`vercel link --repo\` to handle monorepos, or run \`vercel microfrontends pull --cwd=<application-directory>\` to make sure it pulls the \`microfrontends.json\` file to the correct location
+2. If manually defined, move the config file to the \`.vercel\` directory in your application
+3. Alternatively, set the VC_MICROFRONTENDS_CONFIG environment variable to the correct path
+
+For more information, see: https://vercel.com/docs/cli/project-linking`,
+          { type: "config", subtype: "inference_failed" }
+        );
+      }
+      let additionalErrorMessage = "";
+      if (microfrontendsJsonPaths.length > 0) {
+        if (!applicationContext.projectName) {
+          additionalErrorMessage = `
+
+If the name in package.json (${applicationContext.packageJsonName}) differs from your Vercel Project name, set the \`packageName\` field for the application in \`microfrontends.json\` to ensure that the configuration can be found locally.`;
+        } else {
+          additionalErrorMessage = `
+
+Names of applications in \`microfrontends.json\` must match the Vercel Project name (${applicationContext.projectName}).`;
+        }
+      }
+      throw new MicrofrontendError(
+        `Could not find a \`microfrontends.json\` file in the repository that contains the "${applicationName}" application.${additionalErrorMessage}
+
+If your Vercel Microfrontends configuration is not in this repository, you can use the Vercel CLI to pull the Vercel Microfrontends configuration using the "vercel microfrontends pull" command, or you can specify the path manually using the VC_MICROFRONTENDS_CONFIG environment variable.
+
+If your Vercel Microfrontends configuration has a custom name, ensure the VC_MICROFRONTENDS_CONFIG_FILE_NAME environment variable is set, you can pull the vercel project environment variables using the "vercel env pull" command.
+
+If you suspect this is thrown in error, please reach out to the Vercel team.`,
+        { type: "config", subtype: "inference_failed" }
+      );
+    }
+    const [packageJsonPath] = matchingPaths;
+    return dirname(packageJsonPath);
+  } catch (error2) {
+    if (error2 instanceof MicrofrontendError) {
+      throw error2;
+    }
+    return null;
+  }
+}
+function inferMicrofrontendsLocation(opts) {
+  const cacheKey = `${opts.repositoryRoot}-${opts.applicationContext.name}${opts.customConfigFilename ? `-${opts.customConfigFilename}` : ""}`;
+  if (configCache[cacheKey]) {
+    return configCache[cacheKey];
+  }
+  const result = findPackageWithMicrofrontendsConfig(opts);
+  if (!result) {
+    throw new MicrofrontendError(
+      `Could not infer the location of the \`microfrontends.json\` file for application "${opts.applicationContext.name}" starting in directory "${opts.repositoryRoot}".`,
+      { type: "config", subtype: "inference_failed" }
+    );
+  }
+  configCache[cacheKey] = result;
+  return result;
+}
+function existsSync(path7) {
+  try {
+    statSync(path7);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+function doesMisplacedConfigExist(repositoryRoot, applicationName, customConfigFilename) {
+  logger.debug(
+    "[MFE Config] Looking for misplaced config in wrong .vercel directory"
+  );
+  const misplacedConfigPath = join2(
+    repositoryRoot,
+    ".vercel",
+    customConfigFilename || "microfrontends.json"
+  );
+  return existsSync(misplacedConfigPath) && doesApplicationExistInConfig(misplacedConfigPath, applicationName);
+}
+function doesApplicationExistInConfig(microfrontendsJsonPath, applicationName) {
+  try {
+    const microfrontendsJsonContent = readFileSync(
+      microfrontendsJsonPath,
+      "utf-8"
+    );
+    const microfrontendsJson = parse2(microfrontendsJsonContent);
+    if (microfrontendsJson.applications[applicationName]) {
+      logger.debug(
+        "[MFE Config] Found application in config:",
+        microfrontendsJsonPath
+      );
+      return true;
+    }
+    for (const [_, app] of Object.entries(microfrontendsJson.applications)) {
+      if (app.packageName === applicationName) {
+        logger.debug(
+          "[MFE Config] Found application via packageName in config:",
+          microfrontendsJsonPath
+        );
+        return true;
+      }
+    }
+  } catch (error2) {
+    logger.debug("[MFE Config] Error checking application in config:", error2);
+  }
+  return false;
+}
+
+// src/config/microfrontends/utils/is-monorepo.ts
+import fs5 from "node:fs";
+import path4 from "node:path";
+function isMonorepo({
+  repositoryRoot
+}) {
+  try {
+    if (fs5.existsSync(path4.join(repositoryRoot, "pnpm-workspace.yaml"))) {
+      return true;
+    }
+    if (fs5.existsSync(path4.join(repositoryRoot, "vlt-workspaces.json"))) {
+      return true;
+    }
+    if (process.env.NX_WORKSPACE_ROOT === path4.resolve(repositoryRoot)) {
+      return true;
+    }
+    const packageJsonPath = path4.join(repositoryRoot, "package.json");
+    if (!fs5.existsSync(packageJsonPath)) {
+      return false;
+    }
+    const packageJson = JSON.parse(
+      fs5.readFileSync(packageJsonPath, "utf-8")
+    );
+    return packageJson.workspaces !== void 0;
+  } catch (error2) {
+    logger.error("Error determining if repository is a monorepo", error2);
+    return false;
+  }
+}
+
 // src/config/microfrontends/server/utils/get-output-file-path.ts
 import path5 from "node:path";
 
@@ -1140,8 +1252,8 @@ function getOutputFilePath() {
 }
 
 // src/config/microfrontends/server/validation.ts
-import { parse as parse3 } from "jsonc-parser";
 import { Ajv } from "ajv";
+import { parse as parse3 } from "jsonc-parser";
 
 // schema/schema.json
 var schema_default = {
@@ -1169,9 +1281,7 @@ var schema_default = {
           description: "Optional configuration options for the microfrontend."
         }
       },
-      required: [
-        "applications"
-      ],
+      required: ["applications"],
       additionalProperties: false,
       description: "The microfrontends configuration schema. See https://vercel.com/docs/microfrontends/configuration."
     },
@@ -1208,19 +1318,14 @@ var schema_default = {
           description: "Development configuration for the default application."
         }
       },
-      required: [
-        "development"
-      ],
+      required: ["development"],
       additionalProperties: false
     },
     DefaultDevelopment: {
       type: "object",
       properties: {
         local: {
-          type: [
-            "number",
-            "string"
-          ],
+          type: ["number", "string"],
           description: "A local port number or host that this application runs on when it is running locally. If passing a string, include the protocol (optional), host (required) and port (optional).\n\nExamples of valid values: 8080, my.localhost.me, my.localhost.me:8080, https://my.localhost.me, https://my.localhost.me:8080.\n\nThe default value is http://localhost:<port> where port is a stable, unique port number (based on the application name).\n\nSee https://vercel.com/docs/microfrontends/local-development."
         },
         task: {
@@ -1232,9 +1337,7 @@ var schema_default = {
           description: "Fallback for local development, could point to any environment. This is required for the default app. This value is used as the fallback for child apps as well if they do not have a fallback.\n\nIf passing a string, include the protocol (optional), host (required) and port (optional). For example: `https://this.ismyhost:8080`. If omitted, the protocol defaults to HTTPS. If omitted, the port defaults to `80` for HTTP and `443` for HTTPS.\n\nSee https://vercel.com/docs/microfrontends/local-development."
         }
       },
-      required: [
-        "fallback"
-      ],
+      required: ["fallback"],
       additionalProperties: false
     },
     ChildApplication: {
@@ -1257,19 +1360,14 @@ var schema_default = {
           description: "The name of the asset prefix to use instead of the auto-generated name.\n\nThe asset prefix is used to prefix all paths to static assets, such as JS, CSS, or images that are served by a specific application. It is necessary to ensure there are no conflicts with other applications on the same domain.\n\nAn auto-generated asset prefix of the form `vc-ap-<hash>` is used when this field is not provided.\n\nWhen this field is provided, `/${assetPrefix}/:path*` must also be added to the list of paths in the `routing` field. Changing the asset prefix after a microfrontend application has already been deployed is not a forwards and backwards compatible change, and the asset prefix should be added to the `routing` field and deployed before setting the `assetPrefix` field.\n\nThe default value is the auto-generated asset prefix of the form `vc-ap-<hash>`.\n\nSee https://vercel.com/docs/microfrontends/path-routing#asset-prefix."
         }
       },
-      required: [
-        "routing"
-      ],
+      required: ["routing"],
       additionalProperties: false
     },
     ChildDevelopment: {
       type: "object",
       properties: {
         local: {
-          type: [
-            "number",
-            "string"
-          ],
+          type: ["number", "string"],
           description: "A local port number or host that this application runs on when it is running locally. If passing a string, include the protocol (optional), host (required) and port (optional).\n\nExamples of valid values: 8080, my.localhost.me, my.localhost.me:8080, https://my.localhost.me, https://my.localhost.me:8080.\n\nThe default value is http://localhost:<port> where port is a stable, unique port number (based on the application name).\n\nSee https://vercel.com/docs/microfrontends/local-development."
         },
         task: {
@@ -1309,9 +1407,7 @@ var schema_default = {
           description: "A list of path expressions that are routed to this application. See https://vercel.com/docs/microfrontends/path-routing#supported-path-expressions."
         }
       },
-      required: [
-        "paths"
-      ],
+      required: ["paths"],
       additionalProperties: false,
       description: "A group of paths that is routed to this application."
     },
@@ -1490,7 +1586,13 @@ var MicrofrontendsServer = class {
     filePath,
     cookies
   } = {}) {
+    logger.debug("[MFE Config] Starting config inference", {
+      appName,
+      directory: directory || process.cwd(),
+      filePath
+    });
     if (filePath) {
+      logger.debug("[MFE Config] Using explicit filePath:", filePath);
       return MicrofrontendsServer.fromFile({
         filePath,
         cookies
@@ -1498,16 +1600,25 @@ var MicrofrontendsServer = class {
     }
     try {
       const packageRoot = findPackageRoot(directory);
+      logger.debug("[MFE Config] Package root:", packageRoot);
       const applicationContext = getApplicationContext({
         appName,
         packageRoot
       });
+      logger.debug("[MFE Config] Application context:", applicationContext);
       const customConfigFilename = process.env.VC_MICROFRONTENDS_CONFIG_FILE_NAME;
+      if (customConfigFilename) {
+        logger.debug(
+          "[MFE Config] Custom config filename from VC_MICROFRONTENDS_CONFIG_FILE_NAME:",
+          customConfigFilename
+        );
+      }
       const maybeConfig = findConfig({
         dir: packageRoot,
         customConfigFilename
       });
       if (maybeConfig) {
+        logger.debug("[MFE Config] Config found at package root:", maybeConfig);
         return MicrofrontendsServer.fromFile({
           filePath: maybeConfig,
           cookies
@@ -1515,42 +1626,78 @@ var MicrofrontendsServer = class {
       }
       const repositoryRoot = findRepositoryRoot();
       const isMonorepo2 = isMonorepo({ repositoryRoot });
+      logger.debug(
+        "[MFE Config] Repository root:",
+        repositoryRoot,
+        "Is monorepo:",
+        isMonorepo2
+      );
       const configFromEnv = process.env.VC_MICROFRONTENDS_CONFIG;
       if (typeof configFromEnv === "string") {
+        logger.debug(
+          "[MFE Config] Checking VC_MICROFRONTENDS_CONFIG:",
+          configFromEnv
+        );
         const maybeConfigFromEnv = resolve(packageRoot, configFromEnv);
         if (maybeConfigFromEnv) {
+          logger.debug(
+            "[MFE Config] Config loaded from VC_MICROFRONTENDS_CONFIG:",
+            maybeConfigFromEnv
+          );
           return MicrofrontendsServer.fromFile({
             filePath: maybeConfigFromEnv,
             cookies
           });
         }
       } else {
+        const vercelDir = join3(packageRoot, ".vercel");
+        logger.debug(
+          "[MFE Config] Searching for config in .vercel directory:",
+          vercelDir
+        );
         const maybeConfigFromVercel = findConfig({
-          dir: join2(packageRoot, ".vercel"),
+          dir: vercelDir,
           customConfigFilename
         });
         if (maybeConfigFromVercel) {
+          logger.debug(
+            "[MFE Config] Config found in .vercel directory:",
+            maybeConfigFromVercel
+          );
           return MicrofrontendsServer.fromFile({
             filePath: maybeConfigFromVercel,
             cookies
           });
         }
         if (isMonorepo2) {
+          logger.debug(
+            "[MFE Config] Inferring microfrontends location in monorepo for application:",
+            applicationContext.name
+          );
           const defaultPackage = inferMicrofrontendsLocation({
             repositoryRoot,
             applicationContext,
             customConfigFilename
           });
+          logger.debug(
+            "[MFE Config] Inferred package location:",
+            defaultPackage
+          );
           const maybeConfigFromDefault = findConfig({
             dir: defaultPackage,
             customConfigFilename
           });
           if (maybeConfigFromDefault) {
+            logger.debug(
+              "[MFE Config] Config found in inferred package:",
+              maybeConfigFromDefault
+            );
             return MicrofrontendsServer.fromFile({
               filePath: maybeConfigFromDefault,
               cookies
             });
           }
+          logger.debug("[MFE Config] No config found in inferred package");
         }
       }
       throw new MicrofrontendError(
@@ -1576,8 +1723,13 @@ var MicrofrontendsServer = class {
     cookies
   }) {
     try {
+      logger.debug("[MFE Config] Reading config from file:", filePath);
       const configJson = fs6.readFileSync(filePath, "utf-8");
       const config = MicrofrontendsServer.validate(configJson);
+      logger.debug(
+        "[MFE Config] Config loaded with applications:",
+        Object.keys(config.applications)
+      );
       return new MicrofrontendsServer({
         config,
         overrides: cookies ? parseOverrides(cookies) : void 0
@@ -1618,8 +1770,21 @@ var MicrofrontendsServer = class {
 };
 
 // src/utils/mfe-port.ts
+var MFE_APP_PORT_ENV2 = "MFE_APP_PORT";
 function mfePort(packageDir) {
   const { name: appName, version } = getPackageJson(packageDir);
+  const portOverride = process.env[MFE_APP_PORT_ENV2];
+  if (portOverride) {
+    const port = Number.parseInt(portOverride, 10);
+    if (!Number.isNaN(port) && port > 0 && port < 65536) {
+      return {
+        name: appName,
+        version,
+        port,
+        overridden: true
+      };
+    }
+  }
   try {
     const result = loadConfig({ packageDir, appName });
     const { port } = result;
@@ -1650,6 +1815,7 @@ function loadConfig({
   return { port };
 }
 export {
+  MFE_APP_PORT_ENV2 as MFE_APP_PORT_ENV,
   mfePort
 };
 //# sourceMappingURL=mfe-port.js.map