@vercel/microfrontends 0.9.0

package/dist/v2/next/config.cjs

@@ -0,0 +1,1829 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next-v2/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  withMicroFrontends: () => withMicroFrontends
+});
+module.exports = __toCommonJS(config_exports);
+var import_node_fs2 = __toESM(require("fs"), 1);
+
+// src/config-v2/microfrontends/server/index.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = require("path");
+
+// src/config-v2/overrides/constants.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-microfrontends-override";
+var OVERRIDES_ENV_COOKIE_PREFIX = `${OVERRIDES_COOKIE_PREFIX}:env:`;
+
+// src/config-v2/overrides/is-override-cookie.ts
+function isOverrideCookie(cookie) {
+  var _a;
+  return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+}
+
+// src/config-v2/overrides/get-override-from-cookie.ts
+function getOverrideFromCookie(cookie) {
+  if (!isOverrideCookie(cookie) || !cookie.value)
+    return;
+  return {
+    application: cookie.name.replace(OVERRIDES_ENV_COOKIE_PREFIX, ""),
+    host: cookie.value
+  };
+}
+
+// src/config-v2/overrides/parse-overrides.ts
+function parseOverrides(cookies) {
+  const overridesConfig = { applications: {} };
+  cookies.forEach((cookie) => {
+    const override = getOverrideFromCookie(cookie);
+    if (!override)
+      return;
+    overridesConfig.applications[override.application] = {
+      environment: { host: override.host }
+    };
+  });
+  return overridesConfig;
+}
+
+// src/config-v2/errors.ts
+var MicroFrontendError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "MicroFrontendsError";
+    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/micro-frontends";
+    this.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/config-v2/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-v2/microfrontends-config/isomorphic/index.ts
+var import_jsonc_parser = require("jsonc-parser");
+
+// src/config-v2/schema/utils/is-main-config.ts
+function isMainConfig(c) {
+  return !("partOf" in c);
+}
+
+// src/config-v2/schema/utils/is-default-app.ts
+function isDefaultApp(a) {
+  return !("routing" in a);
+}
+
+// src/config-v2/microfrontends-config/client/index.ts
+var import_path_to_regexp = require("path-to-regexp");
+var MicroFrontendConfigClient = class {
+  constructor(config, opts) {
+    this.pathCache = {};
+    this.serialized = config;
+    if (opts == null ? void 0 : opts.removeFlaggedPaths) {
+      for (const app of Object.values(config.applications)) {
+        if (app.routing) {
+          app.routing = app.routing.filter((match) => !match.flag);
+        }
+      }
+    }
+    this.applications = config.applications;
+  }
+  /**
+   * Create a new `MicroFrontendConfigClient` from a JSON string.
+   * Config must be passed in to remain framework agnostic
+   */
+  static fromEnv(config, opts) {
+    if (!config) {
+      throw new Error("No micro-frontends configuration found");
+    }
+    return new MicroFrontendConfigClient(
+      JSON.parse(config),
+      opts
+    );
+  }
+  isEqual(other) {
+    return JSON.stringify(this.applications) === JSON.stringify(other.applications);
+  }
+  getApplicationNameForPath(path2) {
+    if (!path2.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path2]) {
+      return this.pathCache[path2];
+    }
+    const pathname = new URL(path2, "https://example.com").pathname;
+    for (const [name, application] of Object.entries(this.applications)) {
+      if (application.routing) {
+        for (const group of application.routing) {
+          for (const childPath of group.paths) {
+            const regexp = (0, import_path_to_regexp.pathToRegexp)(childPath);
+            if (regexp.test(pathname)) {
+              this.pathCache[path2] = name;
+              return name;
+            }
+          }
+        }
+      }
+    }
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path2] = defaultApplication[0];
+    return defaultApplication[0];
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/validation.ts
+var import_path_to_regexp2 = require("path-to-regexp");
+var SUPPORTED_VERSIONS = ["2"];
+var validateConfigVersion = (version) => {
+  if (!SUPPORTED_VERSIONS.includes(version)) {
+    throw new MicroFrontendError(
+      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
+        ", "
+      )}`,
+      { type: "config", subtype: "unsupported_version" }
+    );
+  }
+};
+var validateConfigPaths = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
+  }
+  const pathsByApplicationId = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const [id, app] of Object.entries(applicationConfigsById)) {
+    if (isDefaultApp(app)) {
+      continue;
+    }
+    for (const pathMatch of app.routing) {
+      for (const path2 of pathMatch.paths) {
+        const tokens = (0, import_path_to_regexp2.parse)(path2);
+        for (const token of tokens.slice(0, -1)) {
+          if (typeof token !== "string") {
+            errors.push(
+              `Path ${path2} may only have a :wildcard in the last path component`
+            );
+          }
+        }
+        const existing = pathsByApplicationId.get(path2);
+        if (existing) {
+          existing.applications.push(id);
+        } else {
+          pathsByApplicationId.set(path2, {
+            applications: [id],
+            matcher: (0, import_path_to_regexp2.pathToRegexp)(path2),
+            applicationId: id
+          });
+        }
+      }
+    }
+  }
+  const entries = Array.from(pathsByApplicationId.entries());
+  entries.forEach(([path2, { applications: ids, matcher, applicationId }]) => {
+    if (ids.length > 1) {
+      errors.push(
+        `Duplicate path "${path2}" for applications "${ids.join(", ")}"`
+      );
+    }
+    entries.forEach(
+      ([
+        matchPath,
+        { applications: matchIds, applicationId: matchApplicationId }
+      ]) => {
+        if (path2 === matchPath) {
+          return;
+        }
+        if (applicationId === matchApplicationId) {
+          return;
+        }
+        if (matcher.test(matchPath)) {
+          const source = `"${path2}" 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 validateAppPaths = (name, app) => {
+  for (const group of app.routing) {
+    for (const p of group.paths) {
+      if (p === "/") {
+        continue;
+      }
+      if (p.endsWith("/")) {
+        throw new MicroFrontendError(
+          `Invalid path for application "${name}". ${p} must not end with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
+      if (!p.startsWith("/")) {
+        throw new MicroFrontendError(
+          `Invalid path for application "${name}". ${p} must start with a slash.`,
+          { type: "application", subtype: "invalid_path" }
+        );
+      }
+    }
+  }
+};
+var validateConfigDefaultApplication = (applicationConfigsById) => {
+  if (!applicationConfigsById) {
+    return;
+  }
+  const applicationsWithRouting = Object.entries(applicationConfigsById).filter(
+    ([, app]) => !isDefaultApp(app)
+  );
+  const applicationsWithRoutingNames = applicationsWithRouting.map(
+    ([key]) => key
+  );
+  const numApplications = Object.keys(applicationConfigsById).length;
+  const numApplicationsWithRouting = applicationsWithRoutingNames.length;
+  const numApplicationsWithoutRouting = numApplications - numApplicationsWithRouting;
+  if (numApplicationsWithoutRouting === 0) {
+    throw new MicroFrontendError(
+      `No default application found. At least one application needs to be the default by omitting routing.`,
+      { type: "config", subtype: "no_default_application" }
+    );
+  }
+  if (numApplicationsWithoutRouting > 1) {
+    throw new MicroFrontendError(
+      `Only one application can omit "routing". Found ${applicationsWithRoutingNames.length - Object.keys(applicationConfigsById).length > 1}.`,
+      { type: "config", subtype: "multiple_default_applications" }
+    );
+  }
+};
+var validateConfigOptions = (options) => {
+  var _a;
+  if ((_a = options == null ? void 0 : options.vercel) == null ? void 0 : _a.previewDeploymentSuffix) {
+    if (!/^[a-zA-Z]{2,}\.[a-zA-Z]{2,}$/.test(
+      options.vercel.previewDeploymentSuffix
+    )) {
+      throw new MicroFrontendError(
+        `Invalid preview deployment suffix: ${options.vercel.previewDeploymentSuffix}. Should have be formatted like "vercel.app".`,
+        { type: "config", subtype: "invalid_preview_deployment_suffix" }
+      );
+    }
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/utils/generate-asset-prefix.ts
+var PREFIX = "vc-ap";
+function generateAssetPrefixFromName({
+  name
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate an asset prefix");
+  }
+  return `${PREFIX}-${name}`;
+}
+
+// src/config-v2/microfrontends-config/isomorphic/utils/generate-port.ts
+function generatePortFromName({
+  name,
+  minPort = 3e3,
+  maxPort = 8e3
+}) {
+  if (!name) {
+    throw new Error("Name is required to generate a port");
+  }
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = (hash << 5) - hash + name.charCodeAt(i);
+    hash |= 0;
+  }
+  hash = Math.abs(hash);
+  const range = maxPort - minPort;
+  const port = minPort + hash % range;
+  return port;
+}
+
+// src/config-v2/microfrontends-config/isomorphic/host.ts
+var Host = class {
+  constructor(hostConfig, options) {
+    const { protocol = "https", host, port } = hostConfig;
+    this.protocol = protocol;
+    this.host = host;
+    this.port = Host.getPort({ port, protocol: this.protocol });
+    this.local = options == null ? void 0 : options.isLocal;
+  }
+  isLocal() {
+    return this.local || this.host === "localhost" || this.host === "127.0.0.1";
+  }
+  static getPort({
+    protocol,
+    port
+  }) {
+    if (!port) {
+      if (protocol === "http") {
+        return 80;
+      }
+      return 443;
+    }
+    return port;
+  }
+  isDefaultPort() {
+    return this.port === 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);
+  }
+};
+var LocalHost = class extends Host {
+  constructor({
+    appName,
+    ...hostConfig
+  }) {
+    const host = hostConfig.host ?? "localhost";
+    const port = hostConfig.port ?? generatePortFromName({ name: appName });
+    const protocol = hostConfig.protocol ?? "http";
+    super({ protocol, host, port });
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/application.ts
+var Application = class {
+  constructor(name, {
+    app,
+    overrides,
+    isDefault
+  }) {
+    var _a, _b;
+    this.name = name;
+    this.development = {
+      local: new LocalHost({
+        appName: name,
+        ...(_a = app.development) == null ? void 0 : _a.local
+      }),
+      fallback: ((_b = app.development) == null ? void 0 : _b.fallback) ? new Host(app.development.fallback) : 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 Host(overrides.environment)
+    } : void 0;
+    this.default = isDefault ?? false;
+    this.serialized = app;
+  }
+  isDefault() {
+    return this.default;
+  }
+  getAssetPrefix() {
+    return generateAssetPrefixFromName({ name: this.name });
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+var DefaultApplication = class extends Application {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    super(name, {
+      app,
+      overrides,
+      isDefault: true
+    });
+    this.default = true;
+    this.production = new Host(app.production);
+  }
+};
+var ChildApplication = class extends Application {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    ChildApplication.validate(name, app);
+    super(name, {
+      app,
+      overrides,
+      isDefault: false
+    });
+    this.default = false;
+    this.routing = app.routing;
+  }
+  static validate(name, app) {
+    validateAppPaths(name, app);
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/constants.ts
+var DEFAULT_LOCAL_PROXY_PORT = 3024;
+
+// src/config-v2/microfrontends-config/isomorphic/index.ts
+var MicroFrontendConfigIsomorphic = class {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    this.childApplications = {};
+    var _a, _b, _c, _d;
+    MicroFrontendConfigIsomorphic.validate(config);
+    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+    this.overrides = overrides && !disableOverrides ? overrides : void 0;
+    this.isMainConfig = isMainConfig(config);
+    if (isMainConfig(config)) {
+      for (const [appId, appConfig] of Object.entries(config.applications)) {
+        const appOverrides = !disableOverrides ? (_c = this.overrides) == null ? void 0 : _c.applications[appId] : void 0;
+        if (isDefaultApp(appConfig)) {
+          this.defaultApplication = new DefaultApplication(appId, {
+            app: appConfig,
+            overrides: appOverrides
+          });
+        } else {
+          this.childApplications[appId] = new ChildApplication(appId, {
+            app: appConfig,
+            overrides: appOverrides
+          });
+        }
+      }
+    } else {
+      this.partOf = config.partOf;
+      const appOverrides = !disableOverrides ? (_d = this.overrides) == null ? void 0 : _d.applications[meta.fromApp] : void 0;
+      this.childApplications[meta.fromApp] = new ChildApplication(
+        meta.fromApp,
+        {
+          // we don't know routing because we're not in the main config
+          app: { routing: [] },
+          overrides: appOverrides
+        }
+      );
+    }
+    if (isMainConfig(config) && !this.defaultApplication) {
+      throw new MicroFrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    this.config = config;
+    this.options = config.options;
+    this.serialized = {
+      config,
+      overrides,
+      meta
+    };
+  }
+  static validate(config) {
+    const c = typeof config === "string" ? (0, import_jsonc_parser.parse)(config) : config;
+    if (isMainConfig(c)) {
+      validateConfigVersion(c.version);
+      validateConfigPaths(c.applications);
+      validateConfigDefaultApplication(c.applications);
+    }
+    validateConfigOptions(c.options);
+    return c;
+  }
+  static fromEnv({
+    meta,
+    cookies
+  }) {
+    return new MicroFrontendConfigIsomorphic({
+      config: (0, import_jsonc_parser.parse)(getConfigStringFromEnv()),
+      overrides: parseOverrides(cookies ?? []),
+      meta
+    });
+  }
+  isOverridesDisabled() {
+    var _a, _b;
+    return ((_b = (_a = this.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getApplicationsByType() {
+    return {
+      defaultApplication: this.defaultApplication,
+      applications: Object.values(this.childApplications)
+    };
+  }
+  getChildApplications() {
+    return Object.values(this.childApplications);
+  }
+  getAllApplications() {
+    return [
+      this.defaultApplication,
+      ...Object.values(this.childApplications)
+    ].filter(Boolean);
+  }
+  getApplication(name) {
+    var _a;
+    if (((_a = this.defaultApplication) == null ? void 0 : _a.name) === name) {
+      return this.defaultApplication;
+    }
+    const app = this.childApplications[name];
+    if (!app) {
+      throw new MicroFrontendError(
+        `Could not find microfrontends configuration for application "${name}"`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    return app;
+  }
+  getApplicationByProjectId(projectId) {
+    var _a, _b;
+    if (((_b = (_a = this.defaultApplication) == null ? void 0 : _a.vercel) == null ? void 0 : _b.projectId) === projectId) {
+      return this.defaultApplication;
+    }
+    return Object.values(this.childApplications).find(
+      (app) => {
+        var _a2;
+        return ((_a2 = app.vercel) == null ? void 0 : _a2.projectId) === projectId;
+      }
+    );
+  }
+  /**
+   * Returns the default application. This can throw if the default application
+   * is undefined ( )
+   */
+  getDefaultApplication() {
+    if (!this.defaultApplication) {
+      throw new MicroFrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    return this.defaultApplication;
+  }
+  /**
+   * Returns the configured port for the local proxy
+   */
+  getLocalProxyPort() {
+    var _a, _b;
+    return ((_b = (_a = this.config.options) == null ? void 0 : _a.localProxy) == null ? void 0 : _b.port) ?? DEFAULT_LOCAL_PROXY_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() {
+    return this.serialized.config;
+  }
+  toClientConfig() {
+    const applications = Object.fromEntries(
+      Object.entries(this.childApplications).map(([name, application]) => [
+        name,
+        {
+          default: false,
+          routing: application.routing
+        }
+      ])
+    );
+    if (this.defaultApplication) {
+      applications[this.defaultApplication.name] = {
+        default: true
+      };
+    }
+    return new MicroFrontendConfigClient({
+      applications
+    });
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/child.ts
+var MicroFrontendChildConfig = class extends MicroFrontendConfigIsomorphic {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    super({ config, overrides, meta });
+    this.isMainConfig = false;
+    this.partOf = config.partOf;
+  }
+};
+
+// src/config-v2/microfrontends-config/isomorphic/main.ts
+var MicroFrontendMainConfig = class extends MicroFrontendConfigIsomorphic {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    var _a, _b, _c;
+    super({ config, overrides, meta });
+    this.isMainConfig = true;
+    this.provider = config.provider;
+    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+    let defaultApplication;
+    for (const [appId, appConfig] of Object.entries(config.applications)) {
+      const appOverrides = !disableOverrides ? (_c = this.overrides) == null ? void 0 : _c.applications[appId] : void 0;
+      if (isDefaultApp(appConfig)) {
+        defaultApplication = new DefaultApplication(appId, {
+          app: appConfig,
+          overrides: appOverrides
+        });
+      } else {
+        this.childApplications[appId] = new ChildApplication(appId, {
+          app: appConfig,
+          overrides: appOverrides
+        });
+      }
+    }
+    if (!defaultApplication) {
+      throw new MicroFrontendError(
+        `Could not find default application in microfrontends configuration`,
+        {
+          type: "application",
+          subtype: "not_found"
+        }
+      );
+    }
+    this.defaultApplication = defaultApplication;
+  }
+};
+
+// src/config-v2/microfrontends/isomorphic/index.ts
+var Microfrontends = class {
+  constructor({
+    config,
+    overrides,
+    meta
+  }) {
+    if (isMainConfig(config)) {
+      this.config = new MicroFrontendMainConfig({ config, overrides, meta });
+    } else {
+      this.config = new MicroFrontendChildConfig({ config, overrides, meta });
+    }
+  }
+  isChildConfig() {
+    return this.config instanceof MicroFrontendChildConfig;
+  }
+  static fromEnv({
+    cookies,
+    meta
+  }) {
+    const config = MicroFrontendConfigIsomorphic.fromEnv({
+      cookies,
+      meta
+    });
+    return new Microfrontends(config.serialize());
+  }
+};
+
+// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
+var import_node_path = __toESM(require("path"), 1);
+
+// 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 import_node_path.default.join(
+      ".vercel",
+      MFE_CONFIG_DEFAULT_FILE_PATH,
+      MFE_CONFIG_DEFAULT_FILE_NAME
+    );
+  }
+  return import_node_path.default.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+}
+
+// src/config-v2/microfrontends/server/validation.ts
+var import_jsonc_parser2 = require("jsonc-parser");
+var import_ajv = require("ajv");
+
+// src/config/errors.ts
+var MicroFrontendError2 = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "MicroFrontendsError";
+    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/micro-frontends";
+    this.type = (opts == null ? void 0 : opts.type) ?? "unknown";
+    this.subtype = opts == null ? void 0 : opts.subtype;
+    Error.captureStackTrace(this, MicroFrontendError2);
+  }
+  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 = MicroFrontendError2.convertFSError(original, opts.fileName);
+      if (err) {
+        return err;
+      }
+    }
+    if (original.message.includes(
+      "Code generation from strings disallowed for this context"
+    )) {
+      return new MicroFrontendError2(original.message, {
+        type: "config",
+        subtype: "unsupported_validation_env",
+        source: "ajv"
+      });
+    }
+    return new MicroFrontendError2(original.message);
+  }
+  static convertFSError(original, fileName) {
+    if (original instanceof Error && "code" in original) {
+      if (original.code === "ENOENT") {
+        return new MicroFrontendError2(`Could not find "${fileName}"`, {
+          type: "config",
+          subtype: "unable_to_read_file",
+          source: "fs"
+        });
+      }
+      if (original.code === "EACCES") {
+        return new MicroFrontendError2(
+          `Permission denied while accessing "${fileName}"`,
+          {
+            type: "config",
+            subtype: "invalid_permissions",
+            source: "fs"
+          }
+        );
+      }
+    }
+    if (original instanceof SyntaxError) {
+      return new MicroFrontendError2(
+        `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 MicroFrontendError2) {
+      return err;
+    }
+    if (err instanceof Error) {
+      return MicroFrontendError2.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 new MicroFrontendError2("An unknown error occurred");
+  }
+};
+
+// schema/schema-v2.json
+var schema_v2_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $ref: "#/definitions/Config",
+  definitions: {
+    Config: {
+      anyOf: [
+        {
+          $ref: "#/definitions/MainConfig"
+        },
+        {
+          $ref: "#/definitions/ChildConfig"
+        }
+      ]
+    },
+    MainConfig: {
+      type: "object",
+      properties: {
+        $schema: {
+          type: "string"
+        },
+        version: {
+          type: "string",
+          const: "2"
+        },
+        options: {
+          $ref: "#/definitions/Options"
+        },
+        remotes: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/Application"
+          },
+          description: "Applications that only serve a subset of the microfrontend routes only need to reference the name of the primary application that owns the full microfrontends configuration."
+        },
+        provider: {
+          $ref: "#/definitions/Provider"
+        },
+        applications: {
+          $ref: "#/definitions/ApplicationRouting",
+          description: "Mapping of application names to the routes that they host. Only needs to be defined in the application that owns the primary microfrontend domain"
+        }
+      },
+      required: ["applications", "provider", "version"]
+    },
+    Options: {
+      type: "object",
+      properties: {
+        vercel: {
+          $ref: "#/definitions/VercelOptions",
+          description: "Micro-Frontends wide options for Vercel."
+        },
+        localProxy: {
+          $ref: "#/definitions/LocalProxyOptions",
+          description: "Options for local proxy."
+        }
+      }
+    },
+    VercelOptions: {
+      type: "object",
+      properties: {
+        previewDeploymentSuffix: {
+          type: "string",
+          description: "If your team uses a custom Preview Deployment Suffix, please specify it here. See https://vercel.com/docs/deployments/preview-deployment-suffix. The default is `vercel.app`."
+        },
+        teamSlug: {
+          type: "string",
+          description: "Team slug for the Vercel team"
+        },
+        disableOverrides: {
+          type: "boolean",
+          description: "If you want to disable the overrides for the site. For example, if you are managing rewrites between applications externally, you may wish to disable the overrides on the toolbar as they will have no effect."
+        }
+      }
+    },
+    LocalProxyOptions: {
+      type: "object",
+      properties: {
+        port: {
+          type: "number",
+          description: "The port number used by the local proxy server.\n\nThe default is `3024`."
+        }
+      }
+    },
+    Application: {
+      anyOf: [
+        {
+          $ref: "#/definitions/DefaultApplication"
+        },
+        {
+          $ref: "#/definitions/ChildApplication"
+        }
+      ]
+    },
+    DefaultApplication: {
+      type: "object",
+      properties: {
+        vercel: {
+          $ref: "#/definitions/Vercel"
+        },
+        development: {
+          $ref: "#/definitions/Development"
+        },
+        production: {
+          $ref: "#/definitions/HostConfig"
+        }
+      },
+      required: ["production"]
+    },
+    Vercel: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Vercel project ID"
+        },
+        routeSpeedInsightsToDefaultZone: {
+          type: "boolean"
+        }
+      },
+      required: ["projectId"]
+    },
+    Development: {
+      type: "object",
+      properties: {
+        local: {
+          $ref: "#/definitions/LocalHostConfig"
+        },
+        fallback: {
+          $ref: "#/definitions/HostConfig",
+          description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
+        },
+        task: {
+          type: "string",
+          description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
+        }
+      }
+    },
+    LocalHostConfig: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "The hostname or IP address of the server. This can be a domain name (e.g., `example.com`) or an IP address (e.g., `192.168.1.1`)."
+        },
+        protocol: {
+          type: "string",
+          enum: ["http", "https"],
+          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "http" for local development, "https" for otherwise'
+        },
+        port: {
+          type: "number",
+          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS."
+        }
+      }
+    },
+    HostConfig: {
+      type: "object",
+      properties: {
+        protocol: {
+          type: "string",
+          enum: ["http", "https"],
+          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "http" for local development, "https" for otherwise'
+        },
+        host: {
+          type: "string",
+          description: "The hostname or IP address of the server. This can be a domain name (e.g., `example.com`) or an IP address (e.g., `192.168.1.1`)."
+        },
+        port: {
+          type: "number",
+          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS."
+        }
+      },
+      required: ["host"]
+    },
+    ChildApplication: {
+      type: "object",
+      properties: {
+        vercel: {
+          $ref: "#/definitions/Vercel"
+        },
+        development: {
+          $ref: "#/definitions/Development"
+        },
+        routing: {
+          $ref: "#/definitions/Routing",
+          description: "Groups of path expressions that are routed to this application."
+        },
+        production: {
+          $ref: "#/definitions/HostConfig"
+        }
+      },
+      required: ["routing"]
+    },
+    Routing: {
+      type: "array",
+      items: {
+        $ref: "#/definitions/PathGroup"
+      }
+    },
+    PathGroup: {
+      type: "object",
+      properties: {
+        group: {
+          type: "string",
+          description: "Optional group name for the paths"
+        },
+        flag: {
+          type: "string",
+          description: "flag name that can be used to enable/disable all paths in the group"
+        },
+        routeToDefaultApplication: {
+          type: "boolean",
+          description: "True to route the request to the default application for this micro-frontends set-up. This must be `true` when using `flag` or when you want to use custom logic to make the routing decision for this group of paths."
+        },
+        paths: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["paths"]
+    },
+    Provider: {
+      type: "string",
+      enum: ["vercel", "other"]
+    },
+    ApplicationRouting: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/definitions/Application"
+      }
+    },
+    ChildConfig: {
+      type: "object",
+      properties: {
+        $schema: {
+          type: "string"
+        },
+        version: {
+          type: "string",
+          const: "2"
+        },
+        options: {
+          $ref: "#/definitions/Options"
+        },
+        remotes: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/definitions/Application"
+          },
+          description: "Applications that only serve a subset of the microfrontend routes only need to reference the name of the primary application that owns the full microfrontends configuration."
+        },
+        partOf: {
+          type: "string",
+          description: "Applications that only serve a subset of the microfrontend routes only need to reference the name of the primary application that owns the full microfrontends configuration."
+        }
+      },
+      required: ["partOf", "version"]
+    }
+  }
+};
+
+// src/config-v2/schema/utils/load.ts
+var SCHEMA = schema_v2_default;
+
+// src/config-v2/microfrontends/server/validation.ts
+function validateSchema(configString) {
+  const parsedConfig = (0, import_jsonc_parser2.parse)(configString);
+  const ajv = new import_ajv.Ajv();
+  const validate = ajv.compile(SCHEMA);
+  const isValid = validate(parsedConfig);
+  if (!isValid) {
+    throw new MicroFrontendError2(
+      `Invalid config: ${ajv.errorsText(validate.errors)}`,
+      { type: "config", subtype: "does_not_match_schema" }
+    );
+  }
+  return parsedConfig;
+}
+
+// src/config-v2/microfrontends/server/index.ts
+var MicrofrontendsServer = class extends Microfrontends {
+  /**
+   * Writes the configuration to a file.
+   */
+  writeConfig(opts = {
+    pretty: true
+  }) {
+    const outputPath = getOutputFilePath();
+    import_node_fs.default.mkdirSync((0, import_node_path2.dirname)(outputPath), { recursive: true });
+    import_node_fs.default.writeFileSync(
+      outputPath,
+      JSON.stringify(
+        this.config.toSchemaJson(),
+        null,
+        opts.pretty ?? true ? 2 : void 0
+      )
+    );
+  }
+  // --------- Static Methods ---------
+  /**
+   * Generates a MicrofrontendsServer instance from an unknown object.
+   */
+  static fromUnknown({
+    config,
+    cookies,
+    meta
+  }) {
+    const overrides = cookies ? parseOverrides(cookies) : void 0;
+    if (typeof config === "string") {
+      return new MicrofrontendsServer({
+        config: MicrofrontendsServer.validate(config),
+        overrides,
+        meta
+      });
+    }
+    if (typeof config === "object") {
+      return new MicrofrontendsServer({
+        config,
+        overrides,
+        meta
+      });
+    }
+    throw new MicroFrontendError(
+      "Invalid config: must be a string or an object",
+      { type: "config", subtype: "does_not_match_schema" }
+    );
+  }
+  /**
+   * Generates a MicrofrontendsServer instance from the environment.
+   * Uses additional validation that is only available when in a node runtime
+   */
+  static fromEnv({
+    cookies,
+    meta
+  }) {
+    return new MicrofrontendsServer({
+      config: MicrofrontendsServer.validate(getConfigStringFromEnv()),
+      overrides: parseOverrides(cookies),
+      meta
+    });
+  }
+  /**
+   * Validates the configuration against the JSON schema
+   */
+  static validate(config) {
+    if (typeof config === "string") {
+      const c = validateSchema(config);
+      return c;
+    }
+    return config;
+  }
+  /*
+   * Generates a MicrofrontendsServer instance from a file.
+   */
+  static fromFile({
+    filePath,
+    cookies,
+    meta
+  }) {
+    try {
+      const config = import_node_fs.default.readFileSync(filePath, "utf-8");
+      return new MicrofrontendsServer({
+        config: MicrofrontendsServer.validate(config),
+        overrides: cookies ? parseOverrides(cookies) : void 0,
+        meta
+      });
+    } catch (e) {
+      throw MicroFrontendError.handle(e, {
+        fileName: filePath
+      });
+    }
+  }
+};
+
+// src/next-v2/utils/check-proxy.ts
+function displayLocalProxyInfo(port) {
+  const { MFE_PROXY_MESSAGE_PRINTED, TURBO_TASK_HAS_MFE_PROXY } = process.env;
+  if (TURBO_TASK_HAS_MFE_PROXY === "true" && MFE_PROXY_MESSAGE_PRINTED !== "true") {
+    process.env.MFE_PROXY_MESSAGE_PRINTED = "true";
+    console.log(`Microfrontends Proxy running on http://localhost:${port}`);
+  }
+}
+
+// src/next-v2/config/transforms/asset-prefix.ts
+function transform(args) {
+  const { next, app } = args;
+  if (app.isDefault()) {
+    return {
+      next
+    };
+  }
+  if (next.assetPrefix !== void 0 && next.assetPrefix !== app.getAssetPrefix()) {
+    console.log(
+      `"assetPrefix" already set. This route must be manually configured in your microfrontend.json file.`
+    );
+  } else {
+    next.assetPrefix = `/${app.getAssetPrefix()}`;
+  }
+  return {
+    next
+  };
+}
+
+// src/next-v2/config/transforms/draft-mode.ts
+function transform2(args) {
+  var _a;
+  const { next } = args;
+  if (((_a = next.experimental) == null ? void 0 : _a.multiZoneDraftMode) !== void 0) {
+    return {
+      next
+    };
+  }
+  next.experimental = next.experimental || {};
+  next.experimental.multiZoneDraftMode = true;
+  return {
+    next
+  };
+}
+
+// src/next-v2/config/transforms/headers.ts
+function transform3(args) {
+  const { next, app } = args;
+  if (app.isDefault()) {
+    return {
+      next
+    };
+  }
+  const headersToAdd = [
+    {
+      source: "/:path*",
+      headers: [
+        {
+          key: "X-Vercel-Zone",
+          value: app.name
+        },
+        {
+          key: "X-Vercel-MFE-App",
+          value: app.name
+        }
+      ]
+    },
+    {
+      source: "/:path*",
+      has: [
+        {
+          type: "host",
+          value: "(?<host>.*)"
+        }
+      ],
+      headers: [
+        {
+          // TODO: we may want to revisit before launch whether we want to expose this
+          // value on all responses publicly since users may not want to reveal this host
+          // (maybe just in preview? or when the user is logged in to the toolbar?)
+          key: "X-Vercel-Host",
+          value: ":host"
+        }
+      ]
+    }
+  ];
+  if (next.headers && typeof next.headers === "function") {
+    const originalHeadersFn = next.headers;
+    next.headers = async () => {
+      const originalHeaders = await originalHeadersFn();
+      return [...originalHeaders, ...headersToAdd];
+    };
+  } else {
+    next.headers = () => {
+      return Promise.resolve(headersToAdd);
+    };
+  }
+  return {
+    next
+  };
+}
+
+// src/routing-v2/get-domain-from-environment.ts
+function getDomainFromEnvironment({
+  app,
+  target
+}) {
+  const projects = JSON.parse(
+    process.env.VERCEL_RELATED_PROJECTS ?? "[]"
+  );
+  if (projects.length === 0) {
+    throw new Error("Missing related vercel project information");
+  }
+  const vercelProject = projects.find(
+    (project) => {
+      var _a;
+      return project.projectId === ((_a = app.vercel) == null ? void 0 : _a.projectId) || project.appName === app.name;
+    }
+  );
+  if (!vercelProject) {
+    throw new Error(
+      `Missing related vercel project information for application "${app.name}"`
+    );
+  }
+  return vercelProject.aliases[target];
+}
+
+// src/routing-v2/get-domain-for-current-environment.ts
+function debugDomains(zone, env, domain) {
+  if (process.env.MFE_DEBUG === "true") {
+    const indent = " ".repeat(4);
+    const header = "domains (zone (env) -> domain)";
+    const separator = "\u23AF".repeat(header.length);
+    const line = `${indent} 1. ${zone} (${env}) -> ${domain}`;
+    console.log(`${indent}${header}
+${indent}${separator}
+${line}
+`);
+  }
+}
+function getCurrentEnvironment() {
+  const isDevelopment = !process.env.VERCEL_ENV || process.env.VERCEL_ENV === "development";
+  const isPreview = process.env.VERCEL_ENV === "preview";
+  const isProduction2 = process.env.VERCEL_ENV === "production";
+  if (isDevelopment) {
+    return { group: "development" };
+  } else if (isProduction2) {
+    return { group: "production" };
+  } else if (isPreview) {
+    return { group: "preview" };
+  }
+  return { group: "custom", name: process.env.VERCEL_ENV };
+}
+function getDomainForCurrentEnvironment(config, appName) {
+  var _a;
+  const app = config.getApplication(appName);
+  if ((_a = app.overrides) == null ? void 0 : _a.environment) {
+    return app.overrides.environment.toString();
+  }
+  const { group } = getCurrentEnvironment();
+  const productionHost = config.getDefaultApplication().production.toString();
+  switch (group) {
+    case "development": {
+      const domain = process.env.NODE_ENV === "test" ? app.development.local.toString() : productionHost;
+      debugDomains(appName, "development", domain);
+      return domain;
+    }
+    case "preview": {
+      return getDomainFromEnvironment({ app, target: "branch" });
+    }
+    case "production": {
+      return getDomainFromEnvironment({ app, target: "production" });
+    }
+    case "custom":
+      console.warn(
+        `Custom environments are not supported in getDomainForCurrentEnvironment`
+      );
+      return productionHost;
+  }
+}
+
+// src/next-v2/config/transforms/rewrites.ts
+function debugRewrites(rewrites) {
+  if (process.env.MFE_DEBUG === "true") {
+    const indent = " ".repeat(4);
+    const header = "rewrites (source \u2192 destination)";
+    const separator = "\u23AF".repeat(header.length);
+    const maxSourceLength = Math.max(
+      ...rewrites.map((key) => key.source.length)
+    );
+    const table = rewrites.map((route, idx) => {
+      const paddedSource = route.source.padEnd(maxSourceLength);
+      return `${indent} ${idx + 1}. ${paddedSource} \u2192  ${route.destination}`;
+    }).join("\n");
+    console.log(`${indent}${header}
+${indent}${separator}
+${table}
+`);
+  }
+}
+function pathToRewrites(path2) {
+  var _a;
+  const regex = /(?<base>^.+)\/:.+\*$/;
+  const match = regex.exec(path2);
+  const paths = [path2];
+  if ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.base) {
+    paths.unshift(match.groups.base);
+  }
+  return paths;
+}
+function rewritesMapToArr(rewrites) {
+  return Array.from(rewrites.entries()).flatMap(([source, rewrite]) => {
+    const destination = `${rewrite.destination.domain || ""}${rewrite.destination.pathname}`;
+    if (source === destination)
+      return [];
+    return [
+      {
+        source,
+        destination
+      }
+    ];
+  });
+}
+function transform4(args) {
+  const { next, microFrontend, app } = args;
+  const buildBeforeFiles = () => {
+    var _a;
+    const rewrites = /* @__PURE__ */ new Map();
+    if (!app.isDefault()) {
+      rewrites.set(`/${app.getAssetPrefix()}/_next/:path+`, {
+        destination: {
+          pathname: `/_next/:path+`
+        }
+      });
+      if (!((_a = app.vercel) == null ? void 0 : _a.routeSpeedInsightsToDefaultZone)) {
+        rewrites.set(`/${app.getAssetPrefix()}/_vercel/:path*`, {
+          destination: { pathname: "/_vercel/:path*" }
+        });
+      }
+    } else if (microFrontend instanceof MicroFrontendMainConfig) {
+      for (const [_, a] of Object.entries(
+        microFrontend.getChildApplications()
+      )) {
+        const { routing } = a;
+        const domain = getDomainForCurrentEnvironment(microFrontend, a.name);
+        rewrites.set(`/${a.getAssetPrefix()}/:path+`, {
+          destination: {
+            domain,
+            pathname: `/${a.getAssetPrefix()}/:path+`
+          }
+        });
+        for (const group of routing) {
+          if (group.routeToDefaultApplication) {
+            continue;
+          } else if (group.flag) {
+            continue;
+          } else {
+            for (const source of group.paths) {
+              const paths = pathToRewrites(source);
+              for (const p of paths) {
+                rewrites.set(p, {
+                  destination: { domain, pathname: p }
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    return rewritesMapToArr(rewrites);
+  };
+  const newBeforeFiles = buildBeforeFiles();
+  if (next.rewrites && typeof next.rewrites === "function") {
+    const originalRewritesFn = next.rewrites;
+    next.rewrites = async () => {
+      const originalRewrites = await originalRewritesFn();
+      if (typeof originalRewrites === "object" && !Array.isArray(originalRewrites)) {
+        const { beforeFiles = [] } = originalRewrites;
+        return {
+          beforeFiles: [...newBeforeFiles, ...beforeFiles],
+          afterFiles: originalRewrites.afterFiles,
+          fallback: originalRewrites.fallback
+        };
+      }
+      return {
+        beforeFiles: newBeforeFiles,
+        afterFiles: originalRewrites,
+        fallback: []
+      };
+    };
+  } else {
+    next.rewrites = async () => ({
+      beforeFiles: newBeforeFiles,
+      afterFiles: [],
+      fallback: []
+    });
+  }
+  debugRewrites(newBeforeFiles);
+  return {
+    next
+  };
+}
+
+// src/next-v2/config/transforms/server-actions.ts
+var formatDomainForServerAction = (domain) => domain.replace(/https?:\/\//, "");
+function transform5(args) {
+  var _a;
+  const { next, app, microFrontend } = args;
+  if (microFrontend instanceof MicroFrontendChildConfig) {
+    console.warn(
+      "server actions transform requires the full config - skipping"
+    );
+    return {
+      next
+    };
+  }
+  const defaultApplication = microFrontend.getDefaultApplication();
+  const appsToAllow = [
+    // this zone - this is included by default unless allowedOrigins is overridden (which we are)
+    // so we re-add it here.
+    app,
+    // this is the default zone for the micro-frontend. Allow child zones to call server actions
+    // that are in the default zone.
+    defaultApplication
+  ];
+  const existingServerActionConfig = (_a = next.experimental) == null ? void 0 : _a.serverActions;
+  next.experimental = {
+    ...next.experimental,
+    serverActions: {
+      ...existingServerActionConfig,
+      allowedOrigins: Array.from(
+        /* @__PURE__ */ new Set([
+          ...(existingServerActionConfig == null ? void 0 : existingServerActionConfig.allowedOrigins) ?? [],
+          ...appsToAllow.flatMap((a) => [
+            formatDomainForServerAction(
+              defaultApplication.production.toString()
+            ),
+            formatDomainForServerAction(
+              getDomainForCurrentEnvironment(microFrontend, a.name)
+            )
+          ])
+        ])
+      )
+    }
+  };
+  return {
+    next
+  };
+}
+
+// src/next-v2/config/transforms/webpack.ts
+function transform6(args) {
+  const { next, microFrontend } = args;
+  const configWithWebpack = {
+    ...next,
+    webpack(cfg, context) {
+      const config = typeof next.webpack === "function" ? next.webpack(cfg, context) : cfg;
+      const { isServer, nextRuntime, webpack: wpFromNext } = context;
+      if (isServer || nextRuntime === "edge") {
+        config.plugins.push(
+          new wpFromNext.EnvironmentPlugin({
+            MFE_CONFIG: JSON.stringify(microFrontend.serialize())
+          })
+        );
+      }
+      config.plugins.push(
+        // Remove node: from import specifiers, because Next.js does not yet support node: scheme
+        // https://github.com/vercel/next.js/issues/28774
+        new wpFromNext.NormalModuleReplacementPlugin(
+          /^node:/,
+          (resource) => {
+            resource.request = resource.request.replace(/^node:/, "");
+          }
+        )
+      );
+      if (!isServer) {
+        config.resolve.fallback = {
+          fs: false,
+          path: false,
+          crypto: false,
+          ...config.resolve.fallback
+        };
+      }
+      return config;
+    }
+  };
+  return {
+    next: configWithWebpack
+  };
+}
+
+// src/next-v2/config/transforms/index.ts
+var transforms = {
+  assetPrefix: transform,
+  draftMode: transform2,
+  headers: transform3,
+  rewrites: transform4,
+  serverActions: transform5,
+  webpack: transform6
+};
+
+// src/next-v2/config/env.ts
+function debugEnv(env) {
+  if (process.env.MFE_DEBUG === "true") {
+    const indent = " ".repeat(4);
+    const header = "env (key \u2192 val)";
+    const separator = "\u23AF".repeat(header.length);
+    const maxKeyLength = Math.max(...Object.keys(env).map((key) => key.length));
+    const table = Object.keys(env).map((key, idx) => {
+      const paddedKey = key.padEnd(maxKeyLength);
+      return `${indent} ${idx + 1}. ${paddedKey} =   ${env[key]}`;
+    }).join("\n");
+    console.log(`${indent}${header}
+${indent}${separator}
+${table}
+`);
+  }
+}
+function setEnvironment({
+  app,
+  microfrontends
+}) {
+  const clientEnvs = {
+    NEXT_PUBLIC_MFE_CURRENT_APPLICATION: app.name,
+    NEXT_PUBLIC_MFE_CLIENT_CONFIG: JSON.stringify(
+      microfrontends.config.toClientConfig().serialize()
+    )
+  };
+  const serverEnvs = {
+    MFE_CURRENT_APPLICATION: app.name,
+    MFE_CONFIG: JSON.stringify(microfrontends.config.getConfig())
+  };
+  const allEnvs = { ...clientEnvs, ...serverEnvs };
+  for (const [key, value] of Object.entries(allEnvs)) {
+    process.env[key] = value;
+  }
+  debugEnv(allEnvs);
+}
+
+// src/next-v2/config/index.ts
+function typedEntries(obj) {
+  return Object.entries(obj);
+}
+function isProduction(opts) {
+  if (opts == null ? void 0 : opts.isProduction) {
+    return opts.isProduction();
+  }
+  return process.env.VERCEL_ENV === "production";
+}
+function getApplicationContext(opts) {
+  if (opts == null ? void 0 : opts.appName) {
+    return { name: opts.appName };
+  }
+  try {
+    const packageJsonString = import_node_fs2.default.readFileSync("./package.json", "utf-8");
+    const packageJson = JSON.parse(packageJsonString);
+    if (!packageJson.name) {
+      throw new MicroFrontendError(
+        `package.json file missing required field "name"`,
+        {
+          type: "packageJson",
+          subtype: "missing_field_name",
+          source: "@vercel/micro-frontends/next"
+        }
+      );
+    }
+    return { name: packageJson.name };
+  } catch (err) {
+    throw MicroFrontendError.handle(err, {
+      fileName: "package.json"
+    });
+  }
+}
+function withMicroFrontends(nextConfig, opts) {
+  var _a;
+  if (opts == null ? void 0 : opts.debug) {
+    process.env.MFE_DEBUG = "true";
+  }
+  const { name: fromApp } = getApplicationContext(opts);
+  const microfrontends = MicrofrontendsServer.fromFile({
+    filePath: (opts == null ? void 0 : opts.configPath) ?? "./microfrontends.json",
+    meta: {
+      fromApp
+    }
+  });
+  const app = microfrontends.config.getApplication(fromApp);
+  setEnvironment({ app, microfrontends });
+  let next = { ...nextConfig };
+  for (const [key, transform7] of typedEntries(transforms)) {
+    if ((_a = opts == null ? void 0 : opts.skipTransforms) == null ? void 0 : _a.includes(key)) {
+      console.log(`Skipping ${key} transform`);
+      continue;
+    }
+    try {
+      const transformedConfig = transform7({
+        app,
+        next,
+        microFrontend: microfrontends.config,
+        opts: {
+          isProduction: isProduction(opts)
+        }
+      });
+      next = transformedConfig.next;
+    } catch (e) {
+      console.error("Error transforming next config", e);
+    }
+  }
+  displayLocalProxyInfo(microfrontends.config.getLocalProxyPort());
+  if (isVercel()) {
+    microfrontends.writeConfig();
+  }
+  return next;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withMicroFrontends
+});
+//# sourceMappingURL=config.cjs.map