@vercel/microfrontends 0.9.0

package/dist/v2/next/middleware.js

@@ -0,0 +1,1082 @@
+// src/next-v2/middleware/middleware.ts
+import { NextResponse } from "next/server";
+import { pathToRegexp as pathToRegexp3 } from "path-to-regexp";
+
+// src/config-v2/microfrontends-config/isomorphic/index.ts
+import { parse } from "jsonc-parser";
+
+// 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/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
+import { pathToRegexp } from "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(path) {
+    if (!path.startsWith("/")) {
+      throw new Error(`Path must start with a /`);
+    }
+    if (this.pathCache[path]) {
+      return this.pathCache[path];
+    }
+    const pathname = new URL(path, "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 = pathToRegexp(childPath);
+            if (regexp.test(pathname)) {
+              this.pathCache[path] = name;
+              return name;
+            }
+          }
+        }
+      }
+    }
+    const defaultApplication = Object.entries(this.applications).find(
+      ([, application]) => application.default
+    );
+    if (!defaultApplication) {
+      return null;
+    }
+    this.pathCache[path] = defaultApplication[0];
+    return defaultApplication[0];
+  }
+  serialize() {
+    return this.serialized;
+  }
+};
+
+// 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/microfrontends-config/isomorphic/validation.ts
+import { pathToRegexp as pathToRegexp2, parse as parsePathRegexp } from "path-to-regexp";
+var SUPPORTED_VERSIONS = ["2"];
+var validateConfigVersion = (version) => {
+  if (!SUPPORTED_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 path of pathMatch.paths) {
+        const tokens = parsePathRegexp(path);
+        for (const token of tokens.slice(0, -1)) {
+          if (typeof token !== "string") {
+            errors.push(
+              `Path ${path} may only have a :wildcard in the last path component`
+            );
+          }
+        }
+        const existing = pathsByApplicationId.get(path);
+        if (existing) {
+          existing.applications.push(id);
+        } else {
+          pathsByApplicationId.set(path, {
+            applications: [id],
+            matcher: pathToRegexp2(path),
+            applicationId: id
+          });
+        }
+      }
+    }
+  }
+  const entries = Array.from(pathsByApplicationId.entries());
+  entries.forEach(([path, { applications: ids, matcher, applicationId }]) => {
+    if (ids.length > 1) {
+      errors.push(
+        `Duplicate path "${path}" for applications "${ids.join(", ")}"`
+      );
+    }
+    entries.forEach(
+      ([
+        matchPath,
+        { applications: matchIds, applicationId: matchApplicationId }
+      ]) => {
+        if (path === matchPath) {
+          return;
+        }
+        if (applicationId === matchApplicationId) {
+          return;
+        }
+        if (matcher.test(matchPath)) {
+          const source = `"${path}" 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" ? 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: 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/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 isProduction = process.env.VERCEL_ENV === "production";
+  if (isDevelopment) {
+    return { group: "development" };
+  } else if (isProduction) {
+    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/middleware/middleware.ts
+async function verifyPreviewDomain(req, rewriteDomain) {
+  var _a;
+  const jwtCookie = (_a = req.cookies.get("_vercel_jwt")) == null ? void 0 : _a.value;
+  const deploymentProtectionBypassHeader = req.headers.get(
+    "x-vercel-protection-bypass"
+  );
+  const previewResponse = await fetch(rewriteDomain, {
+    method: "HEAD",
+    headers: {
+      "x-vercel-micro-frontends-check": "1",
+      ...jwtCookie ? { cookie: `_vercel_jwt=${jwtCookie}` } : {},
+      ...deploymentProtectionBypassHeader ? {
+        "x-vercel-protection-bypass": deploymentProtectionBypassHeader
+      } : {}
+    }
+  });
+  const vercelError = previewResponse.headers.get("x-vercel-error");
+  return !(previewResponse.status === 404 && (vercelError === "DEPLOYMENT_NOT_FOUND" || vercelError === "NOT_FOUND"));
+}
+function microFrontendInternalRoutingHandler({
+  config,
+  production
+}) {
+  return async (req) => {
+    const payload = Object.fromEntries(
+      await Promise.all(
+        config.getAllApplications().map(async (application) => {
+          let rewriteDomain = getDomainForCurrentEnvironment(
+            config,
+            application.name
+          );
+          const isPreviewDomainAvailable = await verifyPreviewDomain(
+            req,
+            rewriteDomain
+          );
+          if (!isPreviewDomainAvailable) {
+            rewriteDomain = production.toString();
+          }
+          return [
+            application.name,
+            { routing: { host: rewriteDomain } }
+          ];
+        })
+      )
+    );
+    return NextResponse.json(payload);
+  };
+}
+function getHandler({
+  config,
+  application,
+  flagFn,
+  pattern,
+  production
+}) {
+  return async (req) => {
+    var _a, _b;
+    const pathname = req.nextUrl.pathname;
+    const search = req.nextUrl.search;
+    let rewriteDomain = getDomainForCurrentEnvironment(
+      config,
+      application.name
+    );
+    const patchedHeaders = new Headers(req.headers);
+    const responseCallbacks = [];
+    const onRewrite = (response) => {
+      for (const callback of responseCallbacks) {
+        callback(response);
+      }
+      return response;
+    };
+    if (process.env.VERCEL_ENV === "preview" && rewriteDomain) {
+      const zoneFallbackCookieName = `__zone_${application.name}_production_fallback`;
+      const assetPrefix = application.getAssetPrefix();
+      if (assetPrefix && pathname.startsWith(`/${assetPrefix}`) && ((_a = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _a.value) === "1") {
+        rewriteDomain = production.toString();
+      } else {
+        try {
+          let deploymentFound;
+          if (req.headers.get("x-vercel-skip-deployment-existence-check")) {
+            deploymentFound = true;
+          } else {
+            deploymentFound = await verifyPreviewDomain(req, rewriteDomain);
+          }
+          if (!deploymentFound) {
+            rewriteDomain = production.toString();
+            responseCallbacks.push((response) => {
+              response.cookies.set(zoneFallbackCookieName, "1", {
+                httpOnly: true,
+                sameSite: "lax",
+                secure: true,
+                maxAge: 60
+                // 1 minute
+              });
+            });
+            try {
+              const existingCookie = patchedHeaders.get("cookie");
+              if (!(existingCookie == null ? void 0 : existingCookie.includes("__vercel_toolbar"))) {
+                patchedHeaders.set(
+                  "cookie",
+                  [`__vercel_toolbar=1`, existingCookie].join("; ")
+                );
+                responseCallbacks.push((response) => {
+                  response.cookies.set("__vercel_toolbar", "1", {
+                    httpOnly: false,
+                    sameSite: "lax",
+                    secure: true,
+                    maxAge: 29030400
+                  });
+                });
+              }
+            } catch (error) {
+            }
+          } else if (((_b = req.cookies.get(zoneFallbackCookieName)) == null ? void 0 : _b.value) === "1") {
+            responseCallbacks.push((response) => {
+              response.cookies.set(zoneFallbackCookieName, "", {
+                httpOnly: true,
+                sameSite: "lax",
+                secure: true,
+                maxAge: 0
+              });
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    const isFlagEnabled = async () => flagFn ? flagFn() : true;
+    if (pattern.test(pathname) && await isFlagEnabled()) {
+      return onRewrite(
+        NextResponse.rewrite(`${rewriteDomain}${pathname}${search}`, {
+          request: {
+            headers: patchedHeaders
+          }
+        })
+      );
+    }
+  };
+}
+function getMicroFrontendsMiddleware({
+  request,
+  flagValues
+}) {
+  const microfrontends = Microfrontends.fromEnv({
+    cookies: request.cookies.getAll(),
+    meta: {
+      fromApp: "vercel-site"
+    }
+  });
+  const middlewares = [];
+  if (microfrontends.config instanceof MicroFrontendChildConfig) {
+    return middlewares;
+  }
+  const config = microfrontends.config;
+  const production = config.defaultApplication.production;
+  middlewares.push({
+    src: "/.well-known/vercel/microfrontend-routing",
+    fn: microFrontendInternalRoutingHandler({ config, production })
+  });
+  for (const application of config.getChildApplications()) {
+    if (application.name === process.env.NEXT_PUBLIC_MFE_CURRENT_APPLICATION) {
+      continue;
+    }
+    if (process.env.VERCEL_ENV === "preview") {
+      const pattern = pathToRegexp3(`/${application.getAssetPrefix()}/:path+`);
+      middlewares.push({
+        src: pattern,
+        fn: getHandler({
+          config,
+          application,
+          pattern,
+          production
+        })
+      });
+    }
+    for (const pathGroup of application.routing) {
+      if (process.env.VERCEL_ENV === "preview" || pathGroup.flag || pathGroup.routeToDefaultApplication) {
+        const flagName = pathGroup.flag;
+        let flagFn;
+        if (flagName) {
+          flagFn = flagValues == null ? void 0 : flagValues[flagName];
+          if (!flagFn) {
+            throw new Error(
+              `Flag "${flagName}" was specified to control routing for path group "${pathGroup.group}" in application ${application.name} but not found in provided flag values.`
+            );
+          }
+        }
+        for (const path of pathGroup.paths) {
+          const pattern = pathToRegexp3(path);
+          middlewares.push({
+            src: pattern,
+            fn: getHandler({
+              config,
+              application,
+              flagFn,
+              pattern,
+              production
+            })
+          });
+        }
+      }
+    }
+  }
+  return middlewares;
+}
+async function runMicroFrontendsMiddleware(request, flagValues) {
+  const pathname = request.nextUrl.pathname;
+  const middlewares = getMicroFrontendsMiddleware({
+    request,
+    flagValues
+  });
+  for (const mware of middlewares) {
+    if (typeof mware.src === "string" ? pathname === mware.src : mware.src.test(pathname)) {
+      const response = await mware.fn(request);
+      if (response) {
+        return response;
+      }
+    }
+  }
+}
+export {
+  getMicroFrontendsMiddleware,
+  runMicroFrontendsMiddleware
+};
+//# sourceMappingURL=middleware.js.map