@vercel/microfrontends 0.9.0

package/dist/next/config.js

@@ -0,0 +1,1758 @@
+// src/next/config/index.ts
+import fs3 from "node:fs";
+
+// src/config/micro-frontend-config.ts
+import fs2 from "node:fs";
+
+// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
+import path from "node:path";
+
+// src/config-v2/microfrontends/server/constants.ts
+var MFE_CONFIG_DEFAULT_FILE_PATH = "microfrontends";
+var MFE_CONFIG_DEFAULT_FILE_NAME = "microfrontends.json";
+
+// src/utils/is-vercel.ts
+function isVercel() {
+  return process.env.VERCEL === "1";
+}
+
+// src/config-v2/microfrontends/server/utils/get-output-file-path.ts
+function getOutputFilePath() {
+  if (isVercel()) {
+    return path.join(
+      ".vercel",
+      MFE_CONFIG_DEFAULT_FILE_PATH,
+      MFE_CONFIG_DEFAULT_FILE_NAME
+    );
+  }
+  return path.join(MFE_CONFIG_DEFAULT_FILE_PATH, MFE_CONFIG_DEFAULT_FILE_NAME);
+}
+
+// src/config/errors.ts
+var MicroFrontendError = class extends Error {
+  constructor(message, opts) {
+    super(message);
+    this.name = "MicroFrontendsError";
+    this.source = (opts == null ? void 0 : opts.source) ?? "@vercel/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/routing/url.ts
+function buildUrlSafeString(givenOpts = {}) {
+  const options = {
+    joinString: "-",
+    lowercaseOnly: true,
+    maxLen: 100,
+    regexRemovePattern: /(?:(?!(?:[a-z0-9])).)/gi,
+    trimWhitespace: true,
+    ...givenOpts
+  };
+  return {
+    generate: (...args) => {
+      const reJoinString = new RegExp(`${options.joinString}+`, "g");
+      let tag;
+      if (args.length === 0) {
+        throw new Error("generate method must be passed at least one argument");
+      }
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (typeof arg !== "string")
+          throw new Error("all supplied arguments must be Strings");
+        if (options.trimWhitespace) {
+          args[i] = arg.trim();
+        }
+      }
+      tag = args.join(options.joinString);
+      tag = tag.replace(/\s/g, options.joinString);
+      if (options.lowercaseOnly)
+        tag = tag.toLowerCase();
+      tag = tag.replace(options.regexRemovePattern, (match) => {
+        if (match === options.joinString)
+          return match;
+        return "";
+      });
+      if (tag.length > options.maxLen)
+        tag = tag.substring(0, options.maxLen);
+      tag = tag.replace(reJoinString, options.joinString);
+      return tag;
+    }
+  };
+}
+var urlSafeString = buildUrlSafeString().generate;
+function makeUrlSafe(name) {
+  return urlSafeString(name.replace(/\//g, "-")).replace(/^-*/g, "").replace(/-*$/g, "");
+}
+
+// src/config/overrides/config.ts
+var OVERRIDES_COOKIE_PREFIX = "vercel-micro-frontends-override";
+var _Overrides = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static getAppEnvOverrideCookieName(zone) {
+    return `${_Overrides.overrideEnvCookiePrefix}${zone}`;
+  }
+  static isOverrideCookie(cookie) {
+    var _a;
+    return Boolean((_a = cookie.name) == null ? void 0 : _a.startsWith(OVERRIDES_COOKIE_PREFIX));
+  }
+  static getOverrideFromCookie(cookie) {
+    if (!_Overrides.isOverrideCookie(cookie) || !cookie.value)
+      return;
+    return {
+      zone: cookie.name.replace(_Overrides.overrideEnvCookiePrefix, ""),
+      host: cookie.value
+    };
+  }
+  static parseOverrides(cookies) {
+    const overridesConfig = { applications: {} };
+    cookies.forEach((cookie) => {
+      const override = _Overrides.getOverrideFromCookie(cookie);
+      if (!override)
+        return;
+      overridesConfig.applications[override.zone] = {
+        environment: { host: override.host }
+      };
+    });
+    return overridesConfig;
+  }
+  static validOverrideDomainsForZone(microFrontendConfig, zone) {
+    var _a, _b, _c, _d, _e;
+    const projectName = (_a = microFrontendConfig.getZone(zone).vercel) == null ? void 0 : _a.projectName;
+    if (!projectName) {
+      return [microFrontendConfig.getZone(zone).production.host];
+    }
+    const parsedProjectName = makeUrlSafe(projectName);
+    const previewDeploymentSuffix = (_c = (_b = microFrontendConfig.options) == null ? void 0 : _b.vercel) == null ? void 0 : _c.previewDeploymentSuffix;
+    const teamSlug = (_e = (_d = microFrontendConfig.options) == null ? void 0 : _d.vercel) == null ? void 0 : _e.teamSlug;
+    if (!teamSlug && !previewDeploymentSuffix) {
+      return [microFrontendConfig.getZone(zone).production.host];
+    }
+    const suffix = previewDeploymentSuffix ? `.${previewDeploymentSuffix}` : `-${teamSlug}.vercel.app`;
+    return [
+      `${parsedProjectName}-git-([a-zA-Z0-9-]+)${suffix}`,
+      microFrontendConfig.getZone(zone).production.host
+    ];
+  }
+  static validateOverrideDomain(microFrontendConfig, zone, domain) {
+    return new RegExp(
+      `^${_Overrides.validOverrideDomainsForZone(microFrontendConfig, zone).join(
+        "|"
+      )}$`
+    ).test(domain);
+  }
+  serialize() {
+    return this.config;
+  }
+};
+var Overrides = _Overrides;
+Overrides.overrideEnvCookiePrefix = `${OVERRIDES_COOKIE_PREFIX}:env:`;
+
+// src/config/common/host.ts
+var Host = class {
+  constructor({ protocol, host, port }) {
+    this.protocol = protocol || "https";
+    this.host = host;
+    this.port = Host.getPort({ port, protocol: this.protocol });
+    this.serialized = {
+      protocol,
+      host,
+      ...port ? { port } : void 0
+    };
+  }
+  isLocal() {
+    return this.host === "localhost" || this.host === "127.0.0.1";
+  }
+  static getPort({
+    protocol,
+    port
+  }) {
+    if (!port) {
+      if (protocol === "http") {
+        return 80;
+      }
+      return 443;
+    }
+    return port;
+  }
+  isDefaultPort() {
+    return this.port === Host.getPort({ protocol: this.protocol });
+  }
+  toString(opts = {}) {
+    const url = this.toUrl(opts);
+    return url.toString().replace(/\/$/, "");
+  }
+  toUrl(opts = {}) {
+    const { includeDefaultPort } = opts;
+    const url = `${this.protocol}://${this.host}${this.isDefaultPort() && !includeDefaultPort ? "" : `:${this.port}`}`;
+    return new URL(url);
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// src/config/common/application.ts
+var Application = class {
+  constructor(name, {
+    app,
+    overrides
+  }) {
+    Application.validate(name, app);
+    this.name = name;
+    this.default = app.default;
+    this.routing = app.routing;
+    this.development = {
+      local: new Host(app.development.local),
+      fallback: app.development.fallback ? new Host(app.development.fallback) : void 0
+    };
+    this.production = new Host(app.production);
+    this.vercel = app.vercel;
+    this.overrides = (overrides == null ? void 0 : overrides.environment) ? {
+      environment: new Host(overrides.environment)
+    } : void 0;
+  }
+  isDefault() {
+    return this.default;
+  }
+  static validate(name, app) {
+    var _a, _b, _c, _d, _e;
+    if (((_b = (_a = app.routing) == null ? void 0 : _a.assetPrefix) == null ? void 0 : _b.startsWith("/")) || ((_d = (_c = app.routing) == null ? void 0 : _c.assetPrefix) == null ? void 0 : _d.endsWith("/"))) {
+      throw new MicroFrontendError(
+        `Invalid assetPrefix for application "${name}". Must not start or end with a slash.`,
+        { type: "zone", subtype: "invalid_asset_prefix" }
+      );
+    }
+    for (const group of ((_e = app.routing) == null ? void 0 : _e.matches) ?? []) {
+      for (const p of group.paths) {
+        if (p === "/") {
+          continue;
+        }
+        if (p.endsWith("/")) {
+          throw new MicroFrontendError(
+            `Invalid path for application "${name}". ${p} must not end with a slash.`,
+            { type: "zone", subtype: "invalid_path" }
+          );
+        }
+        if (!p.startsWith("/")) {
+          throw new MicroFrontendError(
+            `Invalid path for application "${name}". ${p} must start with a slash.`,
+            { type: "zone", subtype: "invalid_path" }
+          );
+        }
+      }
+    }
+  }
+  serialize() {
+    var _a, _b;
+    if (this.routing === void 0 || this.default) {
+      return {
+        default: true,
+        development: {
+          local: this.development.local.serialize(),
+          fallback: (_a = this.development.fallback) == null ? void 0 : _a.serialize()
+        },
+        production: this.production.serialize(),
+        vercel: this.vercel
+      };
+    }
+    return {
+      default: false,
+      routing: this.routing,
+      development: {
+        local: this.development.local.serialize(),
+        fallback: (_b = this.development.fallback) == null ? void 0 : _b.serialize()
+      },
+      production: this.production.serialize(),
+      vercel: this.vercel
+    };
+  }
+};
+
+// src/config/common/micro-frontend-config.ts
+var SUPPORTED_VERSIONS = ["1"];
+var DEFAULT_LOCAL_PROXY_PORT = 3024;
+var MicroFrontendConfigCommon = class {
+  constructor({
+    config,
+    overrides
+  }) {
+    this.zones = {};
+    var _a, _b, _c;
+    if (!SUPPORTED_VERSIONS.includes(config.version)) {
+      throw new MicroFrontendError(
+        `Unsupported version: ${config.version}. Supported versions are: ${SUPPORTED_VERSIONS.join(
+          ", "
+        )}`,
+        { type: "config", subtype: "unsupported_version" }
+      );
+    }
+    const disableOverrides = ((_b = (_a = config.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+    this.overrides = overrides && !disableOverrides ? new Overrides(overrides) : void 0;
+    for (const [zoneName, zoneConfig] of Object.entries(config.applications)) {
+      this.zones[zoneName] = new Application(zoneName, {
+        app: zoneConfig,
+        overrides: !disableOverrides ? (_c = this.overrides) == null ? void 0 : _c.config.applications[zoneName] : void 0
+      });
+    }
+    this.config = config;
+    this.name = config.name;
+    this.version = config.version;
+    this.options = config.options;
+    this.$schema = config.$schema;
+  }
+  isOverridesDisabled() {
+    var _a, _b;
+    return ((_b = (_a = this.options) == null ? void 0 : _a.vercel) == null ? void 0 : _b.disableOverrides) ?? false;
+  }
+  static getConfigFromEnv() {
+    const config = process.env.MFE_CONFIG;
+    if (!config) {
+      throw new MicroFrontendError(`Missing "MFE_CONFIG" in environment.`, {
+        type: "config",
+        subtype: "not_found_in_env"
+      });
+    }
+    return config;
+  }
+  static fromEnv(_) {
+    throw new Error("Not implemented");
+  }
+  getConfig() {
+    return this.config;
+  }
+  getAllApplications() {
+    return Object.values(this.zones);
+  }
+  getZone(name) {
+    const zone = this.zones[name];
+    if (!zone) {
+      throw new MicroFrontendError(
+        `Could not find micro-frontends configuration for application "${name}"`,
+        {
+          type: "zone",
+          subtype: "not_found"
+        }
+      );
+    }
+    return zone;
+  }
+  getApplicationByProjectId(projectId) {
+    return Object.values(this.zones).find(
+      (zone) => {
+        var _a;
+        return ((_a = zone.vercel) == null ? void 0 : _a.projectId) === projectId;
+      }
+    );
+  }
+  getDefaultZone() {
+    const zone = Object.values(this.zones).find((z) => z.default);
+    if (!zone) {
+      throw new MicroFrontendError(
+        `Could not find default zone in micro-frontends configuration`,
+        {
+          type: "zone",
+          subtype: "not_found"
+        }
+      );
+    }
+    return zone;
+  }
+  /**
+   * Returns the configured port for the local proxy
+   */
+  getLocalProxyPort() {
+    var _a, _b;
+    return ((_b = (_a = this.config.options) == null ? void 0 : _a.localProxy) == null ? void 0 : _b.port) ?? DEFAULT_LOCAL_PROXY_PORT;
+  }
+  /**
+   * Serializes the class back to the Schema type.
+   *
+   * NOTE: This is used when writing the config to disk and must always match the input Schema
+   */
+  toSchemaJson() {
+    const applications = {};
+    for (const [name, zone] of Object.entries(this.zones)) {
+      applications[name] = zone.serialize();
+    }
+    return {
+      $schema: this.$schema,
+      name: this.name,
+      version: this.version,
+      options: this.options,
+      applications
+    };
+  }
+  serialize() {
+    var _a;
+    const applications = {};
+    for (const [name, zone] of Object.entries(this.zones)) {
+      applications[name] = zone.serialize();
+    }
+    return {
+      config: {
+        name: this.name,
+        version: this.version,
+        applications,
+        options: this.options,
+        $schema: this.$schema
+      },
+      overrides: (_a = this.overrides) == null ? void 0 : _a.serialize()
+    };
+  }
+  write(_) {
+    throw new MicroFrontendError(
+      `Writing to file to disk requires using an instance of "MicroFrontendConfig".`,
+      { type: "config", subtype: "unsupported_operation" }
+    );
+  }
+};
+
+// src/config/utils/get-output-file-path.ts
+import path2 from "node:path";
+
+// src/config/constants.ts
+var MFE_CONFIG_DEFAULT_FILE_PATH2 = "micro-frontends";
+var MFE_CONFIG_DEFAULT_FILE_NAME2 = "micro-frontends.config.json";
+
+// src/config/utils/get-output-file-path.ts
+function getOutputFilePath2() {
+  if (isVercel()) {
+    return path2.join(
+      ".vercel",
+      MFE_CONFIG_DEFAULT_FILE_PATH2,
+      MFE_CONFIG_DEFAULT_FILE_NAME2
+    );
+  }
+  return path2.join(MFE_CONFIG_DEFAULT_FILE_PATH2, MFE_CONFIG_DEFAULT_FILE_NAME2);
+}
+
+// src/config/validation.ts
+import { parse } from "jsonc-parser";
+import { pathToRegexp, parse as parsePathRegexp } from "path-to-regexp";
+import { Ajv } from "ajv";
+
+// src/config/types.ts
+var isDefaultApplicationConfig = (app) => app.default && typeof app.routing === "undefined";
+
+// schema/schema.json
+var schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $ref: "#/definitions/Config",
+  definitions: {
+    Config: {
+      type: "object",
+      properties: {
+        version: {
+          type: "string"
+        },
+        $schema: {
+          type: "string"
+        },
+        name: {
+          type: "string",
+          description: 'Name for the micro-frontend site (eg. "vercel.com", "vercel-site" etc.).'
+        },
+        applications: {
+          $ref: "#/definitions/ApplicationConfigsById"
+        },
+        options: {
+          $ref: "#/definitions/Options",
+          description: "Optional configuration for the entire micro-frontends setup."
+        }
+      },
+      required: ["version", "applications"],
+      description: "Configuration for micro-frontend applications\n\nTODO: Add proxy configuration"
+    },
+    ApplicationConfigsById: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/definitions/ApplicationConfig"
+      }
+    },
+    ApplicationConfig: {
+      anyOf: [
+        {
+          $ref: "#/definitions/DefaultApplicationConfig"
+        },
+        {
+          $ref: "#/definitions/CommonApplicationConfig"
+        }
+      ],
+      description: "A Micro-Frontend Deployment Target"
+    },
+    DefaultApplicationConfig: {
+      type: "object",
+      properties: {
+        default: {
+          type: "boolean",
+          const: true,
+          description: "The default application is used no other application is matched via the routing config"
+        },
+        routing: {
+          $ref: "#/definitions/Routing"
+        },
+        development: {
+          type: "object",
+          properties: {
+            local: {
+              $ref: "#/definitions/HostConfig"
+            },
+            fallback: {
+              $ref: "#/definitions/HostConfig",
+              description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
+            },
+            task: {
+              type: "string",
+              description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
+            }
+          },
+          required: ["local"]
+        },
+        production: {
+          $ref: "#/definitions/HostConfig"
+        },
+        metadata: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        federation: {
+          type: "object",
+          properties: {
+            exposes: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: {
+                    type: "string",
+                    description: "The name of the module - should be used when importing the module from another application"
+                  },
+                  path: {
+                    type: "string",
+                    description: "Relative path to the module within its `application`"
+                  }
+                },
+                required: ["name", "path"]
+              },
+              description: "Modules that are exposed by this application"
+            },
+            uses: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Modules that are used by this application. Only the name of the module is required."
+            }
+          }
+        },
+        vercel: {
+          $ref: "#/definitions/Vercel"
+        }
+      },
+      required: ["default", "development", "production"]
+    },
+    Routing: {
+      type: "object",
+      properties: {
+        assetPrefix: {
+          type: "string",
+          description: "[assetPrefix] for the application"
+        },
+        matches: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/PathGroup"
+          },
+          description: "Path expressions that are routed to this application."
+        }
+      },
+      required: ["matches"]
+    },
+    PathGroup: {
+      type: "object",
+      properties: {
+        group: {
+          type: "string",
+          description: "Optional group name for the paths"
+        },
+        options: {
+          type: "object",
+          properties: {
+            flag: {
+              type: "string",
+              description: "flag name that can be used to enable/disable all paths in the group"
+            },
+            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"]
+    },
+    HostConfig: {
+      type: "object",
+      properties: {
+        protocol: {
+          type: "string",
+          enum: ["http", "https"],
+          description: 'The protocol to be used for the connection.\n- `http`: Hypertext Transfer Protocol (HTTP).\n- `https`: Secure Hypertext Transfer Protocol (HTTPS).\n\n* @defaultValue "https"'
+        },
+        host: {
+          type: "string",
+          description: "The hostname or IP address of the server. This can be a domain name (e.g., `example.com`) or an IP address (e.g., `192.168.1.1`)."
+        },
+        port: {
+          type: "number",
+          description: "The port number to be used for the connection. Common values include `80` for HTTP and `443` for HTTPS.\n\nThis field is optional and can be omitted if the default ports for the specified protocol are used"
+        }
+      },
+      required: ["host"]
+    },
+    Vercel: {
+      type: "object",
+      properties: {
+        projectId: {
+          type: "string",
+          description: "Vercel project ID"
+        },
+        projectName: {
+          type: "string",
+          description: "Vercel project name (temporary until we can use project ID)"
+        },
+        defaultRoute: {
+          type: "string",
+          description: "The default route for the application. Used to render screenshots, favicons, and provide direct zone links"
+        },
+        routeSpeedInsightsToDefaultZone: {
+          type: "boolean",
+          description: "Whether to route Speed Insights to the default zone or each individual microfrontend."
+        }
+      },
+      required: ["projectId"]
+    },
+    CommonApplicationConfig: {
+      type: "object",
+      properties: {
+        default: {
+          type: "boolean",
+          const: false,
+          description: "The default application is used no other application is matched via the routing config"
+        },
+        routing: {
+          $ref: "#/definitions/Routing"
+        },
+        development: {
+          type: "object",
+          properties: {
+            local: {
+              $ref: "#/definitions/HostConfig"
+            },
+            fallback: {
+              $ref: "#/definitions/HostConfig",
+              description: "Fallback for local development, could be a host config that points to any environment. If this is not provided, or the application is not running - requests to the application in local development will error."
+            },
+            task: {
+              type: "string",
+              description: "Optional task to run when starting the development server. Should reference a script in the package.json of the application."
+            }
+          },
+          required: ["local"]
+        },
+        production: {
+          $ref: "#/definitions/HostConfig"
+        },
+        metadata: {
+          type: "object",
+          additionalProperties: {
+            type: "string"
+          }
+        },
+        federation: {
+          type: "object",
+          properties: {
+            exposes: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: {
+                    type: "string",
+                    description: "The name of the module - should be used when importing the module from another application"
+                  },
+                  path: {
+                    type: "string",
+                    description: "Relative path to the module within its `application`"
+                  }
+                },
+                required: ["name", "path"]
+              },
+              description: "Modules that are exposed by this application"
+            },
+            uses: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Modules that are used by this application. Only the name of the module is required."
+            }
+          }
+        },
+        vercel: {
+          $ref: "#/definitions/Vercel"
+        }
+      },
+      required: ["default", "development", "production", "routing"]
+    },
+    Options: {
+      type: "object",
+      properties: {
+        vercel: {
+          $ref: "#/definitions/VercelOptions",
+          description: "Micro-Frontends wide options for Vercel."
+        },
+        localProxy: {
+          $ref: "#/definitions/LocalProxyOptions",
+          description: "Options for local proxy."
+        }
+      }
+    },
+    VercelOptions: {
+      type: "object",
+      properties: {
+        previewDeploymentSuffix: {
+          type: "string",
+          description: "If your team uses a custom Preview Deployment Suffix, please specify it here. See https://vercel.com/docs/deployments/preview-deployment-suffix. The default is `vercel.app`."
+        },
+        teamSlug: {
+          type: "string",
+          description: "Team slug for the Vercel team"
+        },
+        disableOverrides: {
+          type: "boolean",
+          description: "If you want to disable the overrides for the site. For example, if you are managing rewrites between applications externally, you may wish to disable the overrides on the toolbar as they will have no effect."
+        }
+      }
+    },
+    LocalProxyOptions: {
+      type: "object",
+      properties: {
+        port: {
+          type: "number",
+          description: "The port number used by the local proxy server.\n\nThe default is `3024`."
+        }
+      }
+    }
+  }
+};
+
+// src/config/utils/load-schema.ts
+var SCHEMA = schema_default;
+
+// src/config/validation.ts
+var validateSchema = (configString) => {
+  const parsedConfig = parse(configString);
+  const ajv = new Ajv();
+  const validate = ajv.compile(SCHEMA);
+  const isValid = validate(parsedConfig);
+  if (!isValid) {
+    throw new MicroFrontendError(
+      `Invalid config: ${ajv.errorsText(validate.errors)}`,
+      { type: "config", subtype: "does_not_match_schema" }
+    );
+  }
+  return parsedConfig;
+};
+var SUPPORTED_VERSIONS2 = ["1"];
+var validateVersion = (version) => {
+  if (!SUPPORTED_VERSIONS2.includes(version)) {
+    throw new MicroFrontendError(
+      `Unsupported version: ${version}. Supported versions are: ${SUPPORTED_VERSIONS2.join(
+        ", "
+      )}`,
+      { type: "config", subtype: "unsupported_version" }
+    );
+  }
+};
+function validateMainPath(applicationConfigsById) {
+  for (const [id, app] of Object.entries(applicationConfigsById)) {
+    const { defaultRoute } = app.vercel ?? {};
+    if (!defaultRoute) {
+      continue;
+    }
+    if (isDefaultApplicationConfig(app)) {
+      const pathsWithApp = [];
+      for (const [otherId, otherApp] of Object.entries(
+        applicationConfigsById
+      )) {
+        if (isDefaultApplicationConfig(otherApp)) {
+          continue;
+        }
+        pathsWithApp.push({
+          id: otherId,
+          paths: otherApp.routing.matches.flatMap((match) => match.paths)
+        });
+      }
+      for (const { id: otherId, paths } of pathsWithApp) {
+        const isValid = paths.every((path3) => {
+          const matcher = pathToRegexp(path3);
+          return !matcher.test(defaultRoute);
+        });
+        if (!isValid) {
+          throw new MicroFrontendError(
+            `default route "${defaultRoute}" cannot be used for "${id}" because it is matched by "${otherId}"`,
+            { type: "config", subtype: "invalid_main_path" }
+          );
+        }
+      }
+    } else {
+      const allPaths = app.routing.matches.flatMap((match) => match.paths);
+      const isValid = allPaths.some((path3) => {
+        const matcher = pathToRegexp(path3);
+        return matcher.test(defaultRoute);
+      });
+      if (!isValid) {
+        throw new MicroFrontendError(
+          `default route "${defaultRoute}" is not included by the routing config for application "${id}"`,
+          { type: "config", subtype: "invalid_main_path" }
+        );
+      }
+    }
+  }
+}
+var validatePaths = (applicationConfigsById) => {
+  const pathsByApplicationId = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const [id, app] of Object.entries(applicationConfigsById)) {
+    if (isDefaultApplicationConfig(app)) {
+      continue;
+    }
+    for (const pathMatch of app.routing.matches) {
+      for (const path3 of pathMatch.paths) {
+        const maybeError = validatePathExpression(path3);
+        if (maybeError) {
+          errors.push(maybeError);
+        }
+        const existing = pathsByApplicationId.get(path3);
+        if (existing) {
+          existing.applications.push(id);
+        } else {
+          pathsByApplicationId.set(path3, {
+            applications: [id],
+            matcher: pathToRegexp(path3),
+            applicationId: id
+          });
+        }
+      }
+    }
+  }
+  const entries = Array.from(pathsByApplicationId.entries());
+  entries.forEach(([path3, { applications: ids, matcher, applicationId }]) => {
+    if (ids.length > 1) {
+      errors.push(
+        `Duplicate path "${path3}" for applications "${ids.join(", ")}"`
+      );
+    }
+    entries.forEach(
+      ([
+        matchPath,
+        { applications: matchIds, applicationId: matchApplicationId }
+      ]) => {
+        if (path3 === matchPath) {
+          return;
+        }
+        if (applicationId === matchApplicationId) {
+          return;
+        }
+        if (matcher.test(matchPath)) {
+          const source = `"${path3}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const destination = `"${matchPath}" of application${matchIds.length > 0 ? "s" : ""} ${matchIds.join(", ")}`;
+          errors.push(
+            `Overlapping path detected between ${source} and ${destination}`
+          );
+        }
+      }
+    );
+  });
+  if (errors.length) {
+    throw new MicroFrontendError(`Invalid paths: ${errors.join(", ")}`, {
+      type: "config",
+      subtype: "conflicting_paths"
+    });
+  }
+};
+var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
+function validatePathExpression(path3) {
+  const tokens = parsePathRegexp(path3);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === void 0) {
+      return `token ${i} in ${path3} is undefined, this shouldn't happen`;
+    }
+    if (typeof token !== "string") {
+      if (token.pattern !== PATH_DEFAULT_PATTERN) {
+        return `Path ${path3} cannot use a regular expression wildcard`;
+      }
+      if (token.prefix !== "/") {
+        return `Wildcard :${token.name} must be immediately after a / in ${path3}`;
+      }
+      if (token.suffix) {
+        return `Wildcard suffix on :${token.name} is not allowed. Suffixes are not supported`;
+      }
+      if (token.modifier && i !== tokens.length - 1) {
+        return `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path3}. Modifiers are only allowed in the last path component`;
+      }
+    }
+  }
+  return void 0;
+}
+var validateDefaults = (applicationConfigsById) => {
+  const defaultApplicationIds = Object.entries(applicationConfigsById).reduce((acc, [id, app]) => app.default ? [...acc, id] : acc, []);
+  if (defaultApplicationIds.length === 0) {
+    throw new MicroFrontendError(
+      `No default application found. At least one application must be marked as default.`,
+      { type: "config", subtype: "no_default_application" }
+    );
+  }
+  if (defaultApplicationIds.length > 1) {
+    throw new MicroFrontendError(
+      `Only one default application is allowed. Found ${defaultApplicationIds.join(", ")}.`,
+      { type: "config", subtype: "multiple_default_applications" }
+    );
+  }
+};
+var validateOptions = (options) => {
+  var _a;
+  if ((_a = options == null ? void 0 : options.vercel) == null ? void 0 : _a.previewDeploymentSuffix) {
+    if (!/^[a-zA-Z]{2,}\.[a-zA-Z]{2,}$/.test(
+      options.vercel.previewDeploymentSuffix
+    )) {
+      throw new MicroFrontendError(
+        `Invalid preview deployment suffix: ${options.vercel.previewDeploymentSuffix}. Should have be formatted like "vercel.app".`,
+        { type: "config", subtype: "invalid_preview_deployment_suffix" }
+      );
+    }
+  }
+};
+
+// src/config/utils/convert.ts
+function convertV1RoutingToV2Routing(routing) {
+  return routing.matches.map((group) => {
+    var _a, _b;
+    return {
+      group: group.group,
+      flag: (_a = group.options) == null ? void 0 : _a.flag,
+      routeToDefaultApplication: (_b = group.options) == null ? void 0 : _b.routeToDefaultApplication,
+      paths: group.paths
+    };
+  });
+}
+function convertV1ApplicationToV2Application(application) {
+  const common = {
+    production: application.production,
+    development: application.development,
+    vercel: application.vercel
+  };
+  if (application.default) {
+    return common;
+  }
+  return {
+    ...common,
+    routing: convertV1RoutingToV2Routing(application.routing)
+  };
+}
+function convertV1ConfigToV2Config(config, fromApp) {
+  if (!config.applications[fromApp]) {
+    throw new Error(`Application "${fromApp}" not found in the config`);
+  }
+  const common = {
+    version: "2",
+    options: config.options
+  };
+  if (config.applications[fromApp].default) {
+    return {
+      ...common,
+      // this is assumed for now, and by the time this is released we won't need this conversion
+      provider: "vercel",
+      applications: Object.fromEntries(
+        Object.entries(config.applications).map(([id, application]) => [
+          id,
+          convertV1ApplicationToV2Application(application)
+        ])
+      )
+    };
+  }
+  return {
+    ...common,
+    partOf: fromApp
+  };
+}
+
+// src/config/utils/write-file.ts
+import fs from "node:fs";
+import { dirname } from "node:path";
+function writeFile(outputPath, config, prettify) {
+  fs.mkdirSync(dirname(outputPath), { recursive: true });
+  fs.writeFileSync(
+    outputPath,
+    JSON.stringify(config, null, prettify ? 2 : void 0)
+  );
+}
+
+// src/config/micro-frontend-config.ts
+var MicroFrontendConfig = class extends MicroFrontendConfigCommon {
+  static validate(configString) {
+    const config = validateSchema(configString);
+    validateVersion(config.version);
+    validatePaths(config.applications);
+    validateMainPath(config.applications);
+    validateDefaults(config.applications);
+    validateOptions(config.options);
+    return config;
+  }
+  static fromEnv({
+    cookies
+  }) {
+    return new MicroFrontendConfigCommon({
+      config: MicroFrontendConfig.validate(
+        MicroFrontendConfigCommon.getConfigFromEnv()
+      ),
+      overrides: Overrides.parseOverrides(cookies)
+    });
+  }
+  static fromFile({
+    filePath
+  }) {
+    try {
+      const config = fs2.readFileSync(filePath, "utf-8");
+      return new MicroFrontendConfig({
+        config: MicroFrontendConfig.validate(config)
+      });
+    } catch (e) {
+      throw MicroFrontendError.handle(e, {
+        fileName: filePath
+      });
+    }
+  }
+  /**
+   * Writes the configuration to a file.
+   */
+  write(fromApp, opts = {}) {
+    const { pretty = true, versions = ["v1", "v2"] } = opts;
+    const config = this.toSchemaJson();
+    if (versions.includes("v1")) {
+      const outputPath = getOutputFilePath2();
+      writeFile(outputPath, config, pretty);
+    }
+    if (versions.includes("v2")) {
+      const outputPath = getOutputFilePath();
+      const v2Config = convertV1ConfigToV2Config(config, fromApp);
+      writeFile(outputPath, v2Config, pretty);
+    }
+  }
+};
+
+// src/next/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/config/transforms/asset-prefix.ts
+function transform(args) {
+  var _a;
+  const { next, zone } = args;
+  if (!((_a = zone.routing) == null ? void 0 : _a.assetPrefix)) {
+    return {
+      next
+    };
+  }
+  if (next.assetPrefix !== void 0 && next.assetPrefix !== zone.routing.assetPrefix) {
+    throw new Error(
+      `"assetPrefix" already set. Overwriting with "${zone.name}"`
+    );
+  }
+  next.assetPrefix = `/${zone.routing.assetPrefix}`;
+  return {
+    next
+  };
+}
+
+// src/next/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/config/transforms/headers.ts
+function transform3(args) {
+  const { next, zone } = args;
+  if (zone.isDefault()) {
+    return {
+      next
+    };
+  }
+  const headersToAdd = [
+    {
+      source: "/:path*",
+      headers: [
+        {
+          key: "X-Vercel-Zone",
+          value: zone.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/get-preview-domain.ts
+import { createHash } from "node:crypto";
+var DOMAIN_SIZE = 253;
+var DOMAIN_LABEL_SIZE = 63;
+function getMaxLabelLength(domain) {
+  return Math.min(DOMAIN_SIZE - domain.length - 1, DOMAIN_LABEL_SIZE);
+}
+function parseBranchUrl(branchUrl) {
+  const branchUrlParts = branchUrl.split(".");
+  if (branchUrlParts.length < 3) {
+    throw new Error(`Could not parse Vercel branch URL "${branchUrl}"`);
+  }
+  const domain = [branchUrlParts[1], branchUrlParts[2]].join(".");
+  return {
+    // biome-ignore lint/style/noNonNullAssertion: Ignored using `--suppress`
+    label: branchUrlParts[0],
+    domain
+  };
+}
+function getDomainSuffix(branchUrl, vercelUrl) {
+  const branchLabelParts = parseBranchUrl(branchUrl).label.split("-");
+  const vercelUrlLabelParts = parseBranchUrl(vercelUrl).label.split("-");
+  const suffixParts = [];
+  for (let i = 1; i < branchLabelParts.length; i++) {
+    if (branchLabelParts.at(-1 * i) === vercelUrlLabelParts.at(-1 * i)) {
+      suffixParts.push(branchLabelParts.at(-1 * i) ?? "");
+    }
+  }
+  return suffixParts.reverse().filter(Boolean).join("-");
+}
+function getPreviewDomain(zone) {
+  var _a;
+  const targetVercelProjectName = (_a = zone.vercel) == null ? void 0 : _a.projectName;
+  if (!targetVercelProjectName) {
+    throw new Error(
+      `Missing Vercel project configuration for application "${zone.name}"`
+    );
+  }
+  const { VERCEL_GIT_COMMIT_REF, VERCEL_BRANCH_URL, VERCEL_URL } = process.env;
+  if (VERCEL_GIT_COMMIT_REF && VERCEL_BRANCH_URL && VERCEL_URL) {
+    const branchUrlParts = parseBranchUrl(VERCEL_BRANCH_URL);
+    const { domain } = branchUrlParts;
+    const stagingSuffix = domain !== "vercel.sh" ? getDomainSuffix(VERCEL_BRANCH_URL, VERCEL_URL) : "";
+    const gitBranch = `git-${VERCEL_GIT_COMMIT_REF.toLocaleLowerCase()}`;
+    const gitBranchForHash = `git-${VERCEL_GIT_COMMIT_REF}`;
+    const urlSafeBranch = makeUrlSafe(gitBranch);
+    const urlSafeProjectName = makeUrlSafe(targetVercelProjectName);
+    const maxLabelLength = getMaxLabelLength(domain);
+    const label = [urlSafeProjectName, urlSafeBranch, stagingSuffix].filter(Boolean).join("-");
+    if (label.length > maxLabelLength) {
+      let newLabel = makeUrlSafe(stagingSuffix).slice(0, maxLabelLength);
+      const hash = createHash("sha256").update(`${gitBranchForHash}${targetVercelProjectName}`).digest("hex").slice(0, 6);
+      newLabel = [hash, newLabel].filter(Boolean).join("-");
+      const projectNamePart = makeUrlSafe(
+        urlSafeProjectName.slice(0, maxLabelLength - newLabel.length - 1 - 4)
+      );
+      const branchPart = makeUrlSafe(
+        urlSafeBranch.slice(
+          0,
+          Math.max(
+            0,
+            maxLabelLength - (newLabel.length + projectNamePart.length) - 2
+          )
+        )
+      );
+      if (branchPart.length >= 3) {
+        newLabel = [branchPart, newLabel].filter(Boolean).join("-");
+      }
+      if (projectNamePart) {
+        newLabel = [projectNamePart, newLabel].filter(Boolean).join("-");
+      }
+      return `https://${newLabel}.${domain}`;
+    }
+    return `https://${label}.${domain}`;
+  }
+  return zone.production.toString();
+}
+
+// src/routing/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 getDomainForCurrentEnvironment(zone) {
+  var _a;
+  if ((_a = zone.overrides) == null ? void 0 : _a.environment) {
+    return zone.overrides.environment.toString();
+  }
+  const zoneName = zone.name;
+  if (!process.env.VERCEL_ENV || process.env.VERCEL_ENV === "development") {
+    const domain = process.env.NODE_ENV === "test" ? zone.development.local.toString() : zone.production.toString();
+    debugDomains(zoneName, "development", domain);
+    return domain;
+  } else if (process.env.VERCEL_ENV === "production") {
+    const domain = zone.production.toString();
+    debugDomains(zoneName, "production", domain);
+    return domain;
+  } else if (process.env.VERCEL_ENV === "preview") {
+    const MFE_PREVIEW_DOMAINS = JSON.parse(
+      process.env.MFE_PREVIEW_DOMAINS ?? "{}"
+    );
+    if (MFE_PREVIEW_DOMAINS[zoneName]) {
+      debugDomains(zoneName, "preview", MFE_PREVIEW_DOMAINS[zoneName]);
+      return MFE_PREVIEW_DOMAINS[zoneName];
+    }
+    throw new Error(
+      `Could not find preview domain for application "${zoneName}"`
+    );
+  }
+  debugDomains(zoneName, process.env.VERCEL_ENV, zone.production.toString());
+  return zone.production.toString();
+}
+
+// src/next/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(path3) {
+  var _a;
+  const regex = /(?<base>^.+)\/:.+\*$/;
+  const match = regex.exec(path3);
+  const paths = [path3];
+  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, zone } = args;
+  const buildBeforeFiles = () => {
+    var _a, _b, _c, _d, _e;
+    const rewrites = /* @__PURE__ */ new Map();
+    if ((_a = zone.routing) == null ? void 0 : _a.assetPrefix) {
+      rewrites.set(`/${zone.routing.assetPrefix}/_next/:path+`, {
+        destination: {
+          pathname: `/_next/:path+`
+        }
+      });
+      if (!((_b = zone.vercel) == null ? void 0 : _b.routeSpeedInsightsToDefaultZone)) {
+        rewrites.set(`/${zone.routing.assetPrefix}/_vercel/:path*`, {
+          destination: { pathname: "/_vercel/:path*" }
+        });
+      }
+    }
+    if (zone.isDefault()) {
+      for (const [_, z] of Object.entries(microFrontend.zones)) {
+        if (zone.name === z.name) {
+          continue;
+        }
+        const { routing } = z;
+        if (!routing) {
+          continue;
+        }
+        const domain = process.env.VERCEL_ENV === "preview" ? getPreviewDomain(z) : getDomainForCurrentEnvironment(z);
+        if ((_c = z.routing) == null ? void 0 : _c.assetPrefix) {
+          rewrites.set(`/${z.routing.assetPrefix}/:path+`, {
+            destination: {
+              domain,
+              pathname: `/${z.routing.assetPrefix}/:path+`
+            }
+          });
+        }
+        for (const group of routing.matches) {
+          if ((_d = group.options) == null ? void 0 : _d.routeToDefaultApplication) {
+            continue;
+          } else if ((_e = group.options) == null ? void 0 : _e.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 }
+                });
+              }
+            }
+          }
+        }
+      }
+    } else {
+    }
+    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/config/transforms/server-actions.ts
+var formatDomainForServerAction = (domain) => domain.replace(/https?:\/\//, "");
+function transform5(args) {
+  var _a;
+  const { next, zone, microFrontend } = args;
+  const zonesToAllow = [
+    // this zone - this is included by default unless allowedOrigins is overridden (which we are)
+    // so we re-add it here.
+    zone,
+    // this is the default zone for the micro-frontend. Allow child zones to call server actions
+    // that are in the default zone.
+    microFrontend.getDefaultZone()
+  ];
+  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) ?? [],
+          ...zonesToAllow.flatMap((z) => [
+            formatDomainForServerAction(z.production.toString()),
+            formatDomainForServerAction(getDomainForCurrentEnvironment(z))
+          ])
+        ])
+      )
+    }
+  };
+  return {
+    next
+  };
+}
+
+// src/next/config/transforms/webpack.ts
+function transform6(args) {
+  const { next, microFrontend } = args;
+  const previewDomains = process.env.VERCEL_ENV === "preview" ? microFrontend.getAllApplications().reduce(
+    (obj, app) => {
+      obj[app.name] = getPreviewDomain(app);
+      return obj;
+    },
+    // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter -- needed to satisfy TSC
+    {}
+  ) : {};
+  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()),
+            MFE_PREVIEW_DOMAINS: JSON.stringify(previewDomains)
+          })
+        );
+      }
+      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/config/transforms/index.ts
+var transforms = {
+  assetPrefix: transform,
+  draftMode: transform2,
+  headers: transform3,
+  rewrites: transform4,
+  serverActions: transform5,
+  webpack: transform6
+};
+
+// src/config/client/client-config.ts
+function getConfigForClient(config) {
+  return {
+    applications: Object.fromEntries(
+      Object.entries(config.applications).map(([name, application]) => [
+        name,
+        {
+          default: application.default,
+          routing: application.routing
+        }
+      ])
+    )
+  };
+}
+
+// src/next/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({
+  zone,
+  config
+}) {
+  var _a, _b, _c, _d;
+  const previewDomains = process.env.VERCEL_ENV === "preview" ? config.getAllApplications().reduce(
+    (obj, app) => {
+      obj[app.name] = getPreviewDomain(app);
+      return obj;
+    },
+    // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter -- needed to satisfy TSC
+    {}
+  ) : {};
+  const clientEnvs = {
+    NEXT_PUBLIC_MFE_CURRENT_APPLICATION: zone.name,
+    NEXT_PUBLIC_MFE_CLIENT_CONFIG: JSON.stringify(
+      getConfigForClient(config.getConfig())
+    ),
+    ...((_a = zone.vercel) == null ? void 0 : _a.routeSpeedInsightsToDefaultZone) && ((_b = zone.routing) == null ? void 0 : _b.assetPrefix) ? {} : {
+      NEXT_PUBLIC_SPEED_INSIGHTS_BASEPATH: (_c = zone.routing) == null ? void 0 : _c.assetPrefix,
+      NEXT_PUBLIC_WEB_ANALYTICS_BASEPATH: (_d = zone.routing) == null ? void 0 : _d.assetPrefix
+    }
+  };
+  const serverEnvs = {
+    MFE_CURRENT_APPLICATION: zone.name,
+    MFE_PREVIEW_DOMAINS: JSON.stringify(previewDomains),
+    MFE_CONFIG: JSON.stringify(config.getConfig())
+  };
+  const allEnvs = { ...clientEnvs, ...serverEnvs };
+  for (const [key, value] of Object.entries(allEnvs)) {
+    process.env[key] = value;
+  }
+  debugEnv(allEnvs);
+}
+
+// src/next/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 getConfigPath(opts) {
+  var _a;
+  if (opts == null ? void 0 : opts.configPath) {
+    return { configPath: opts.configPath };
+  }
+  try {
+    const vercelJsonString = fs3.readFileSync("./vercel.json", "utf-8");
+    const vercelJson = JSON.parse(vercelJsonString);
+    if (!((_a = vercelJson.microFrontends) == null ? void 0 : _a.config)) {
+      throw new MicroFrontendError(
+        `vercel.json file missing required field "microFrontends.config"`,
+        {
+          type: "vercelJson",
+          subtype: "missing_field_microFrontend_config_path",
+          source: "@vercel/micro-frontends/next"
+        }
+      );
+    }
+    return { configPath: vercelJson.microFrontends.config };
+  } catch (err) {
+    throw MicroFrontendError.handle(err, {
+      fileName: "vercel.json"
+    });
+  }
+}
+function getApplicationContext(opts) {
+  if (opts == null ? void 0 : opts.appName) {
+    return { name: opts.appName };
+  }
+  try {
+    const packageJsonString = fs3.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 } = getApplicationContext(opts);
+  const { configPath } = getConfigPath(opts);
+  const mfConfig = MicroFrontendConfig.fromFile({
+    filePath: configPath
+  });
+  const zone = mfConfig.getZone(name);
+  setEnvironment({ zone, config: mfConfig });
+  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({
+        zone,
+        next,
+        microFrontend: mfConfig,
+        opts: {
+          isProduction: isProduction(opts)
+        }
+      });
+      next = transformedConfig.next;
+    } catch (e) {
+      console.error("Error transforming next config", e);
+    }
+  }
+  displayLocalProxyInfo(mfConfig.getLocalProxyPort());
+  if (isVercel()) {
+    mfConfig.write(zone.name, { versions: ["v1", "v2"] });
+  }
+  return next;
+}
+export {
+  withMicroFrontends
+};
+//# sourceMappingURL=config.js.map