@vercel/microfrontends 0.10.0 → 0.10.1

package/README.md

@@ -89,17 +89,17 @@ the `files` attribute.
 #### `next.config.js`
 
 In the `next.config.js` configuration for your application, wrap your config
-with the `withMicroFrontends` function specifying the `micro-frontends.json`
+with the `withMicrofrontends` function specifying the `micro-frontends.json`
 config that you created above.
 
 ```js filename="next.config.js"
-const { withMicroFrontends } = require('@vercel/microfrontends/next/config');
+const { withMicrofrontends } = require('@vercel/microfrontends/next/config');
 
 const nextConfig = {
   // ...
 };
 
-module.exports = withMicroFrontends(
+module.exports = withMicrofrontends(
   nextConfig,
   path.join(
     __dirname,
@@ -117,13 +117,13 @@ Next you have to include the micro-frontends middleware. You can run this code
 in your middleware to apply the micro-frontends routing logic.
 
 ```typescript filename="middleware.ts"
-import { runMicroFrontendsMiddleware } from '@vercel/microfrontends/next/middleware';
+import { runMicrofrontendsMiddleware } from '@vercel/microfrontends/next/middleware';
 
 export async function middleware(
   request: NextRequest,
   event: NextFetchEvent,
 ): Promise<Response> {
-  let response = await runMicroFrontendsMiddleware(request);
+  let response = await runMicrofrontendsMiddleware(request);
   if (response) {
     return response;
   }

package/dist/bin/cli.cjs

@@ -29,7 +29,7 @@ var import_commander = require("commander");
 // package.json
 var package_default = {
   name: "@vercel/microfrontends",
-  version: "0.10.0",
+  version: "0.10.1",
   private: false,
   description: "Defines configuration and utilities for micro-frontend development",
   repository: {
@@ -161,6 +161,7 @@ var package_default = {
     ajv: "^8.17.1",
     commander: "^12.1.0",
     cookie: "0.4.0",
+    "fast-glob": "^3.3.2",
     "http-proxy": "^1.18.1",
     "jsonc-parser": "^3.3.1",
     "path-to-regexp": "6.2.1"
@@ -180,9 +181,9 @@ var package_default = {
     "@vercel-private/conformance": "^1.12.2-canary.0",
     jest: "^29.7.0",
     "jest-environment-jsdom": "29.2.2",
-    next: "15.0.4-canary.26",
-    react: "19.0.0-rc-380f5d67-20241113",
-    "react-dom": "19.0.0-rc-380f5d67-20241113",
+    next: "15.0.4-canary.41",
+    react: "19.0.0-rc-de68d2f4-20241204",
+    "react-dom": "19.0.0-rc-de68d2f4-20241204",
     "ts-json-schema-generator": "^1.1.2",
     tsup: "^6.6.2",
     tsx: "^4.6.2",
@@ -190,9 +191,9 @@ var package_default = {
     webpack: "5"
   },
   peerDependencies: {
-    next: "15.0.4-canary.26",
-    react: "19.0.0-rc-380f5d67-20241113",
-    "react-dom": "19.0.0-rc-380f5d67-20241113"
+    next: "15.0.4-canary.41",
+    react: "19.0.0-rc-de68d2f4-20241204",
+    "react-dom": "19.0.0-rc-de68d2f4-20241204"
   },
   publishConfig: {
     access: "restricted"
@@ -873,10 +874,6 @@ var schema_default = {
             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."
             }
           }
         },
@@ -1093,8 +1090,8 @@ function validateMainPath(applicationConfigsById) {
         });
       }
       for (const { id: otherId, paths } of pathsWithApp) {
-        const isValid = paths.every((path3) => {
-          const matcher = (0, import_path_to_regexp.pathToRegexp)(path3);
+        const isValid = paths.every((path4) => {
+          const matcher = (0, import_path_to_regexp.pathToRegexp)(path4);
           return !matcher.test(defaultRoute);
         });
         if (!isValid) {
@@ -1106,8 +1103,8 @@ function validateMainPath(applicationConfigsById) {
       }
     } else {
       const allPaths = app.routing.matches.flatMap((match) => match.paths);
-      const isValid = allPaths.some((path3) => {
-        const matcher = (0, import_path_to_regexp.pathToRegexp)(path3);
+      const isValid = allPaths.some((path4) => {
+        const matcher = (0, import_path_to_regexp.pathToRegexp)(path4);
         return matcher.test(defaultRoute);
       });
       if (!isValid) {
@@ -1127,18 +1124,18 @@ var validatePaths = (applicationConfigsById) => {
       continue;
     }
     for (const pathMatch of app.routing.matches) {
-      for (const path3 of pathMatch.paths) {
-        const maybeError = validatePathExpression(path3);
+      for (const path4 of pathMatch.paths) {
+        const maybeError = validatePathExpression(path4);
         if (maybeError) {
           errors.push(maybeError);
         }
-        const existing = pathsByApplicationId.get(path3);
+        const existing = pathsByApplicationId.get(path4);
         if (existing) {
           existing.applications.push(id);
         } else {
-          pathsByApplicationId.set(path3, {
+          pathsByApplicationId.set(path4, {
             applications: [id],
-            matcher: (0, import_path_to_regexp.pathToRegexp)(path3),
+            matcher: (0, import_path_to_regexp.pathToRegexp)(path4),
             applicationId: id
           });
         }
@@ -1146,10 +1143,10 @@ var validatePaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  entries.forEach(([path3, { applications: ids, matcher, applicationId }]) => {
+  entries.forEach(([path4, { applications: ids, matcher, applicationId }]) => {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path3}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path4}" for applications "${ids.join(", ")}"`
       );
     }
     entries.forEach(
@@ -1157,14 +1154,14 @@ var validatePaths = (applicationConfigsById) => {
         matchPath,
         { applications: matchIds, applicationId: matchApplicationId }
       ]) => {
-        if (path3 === matchPath) {
+        if (path4 === matchPath) {
           return;
         }
         if (applicationId === matchApplicationId) {
           return;
         }
         if (matcher.test(matchPath)) {
-          const source = `"${path3}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const source = `"${path4}" 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}`
@@ -1181,25 +1178,25 @@ var validatePaths = (applicationConfigsById) => {
   }
 };
 var PATH_DEFAULT_PATTERN = "[^\\/#\\?]+?";
-function validatePathExpression(path3) {
-  const tokens = (0, import_path_to_regexp.parse)(path3);
+function validatePathExpression(path4) {
+  const tokens = (0, import_path_to_regexp.parse)(path4);
   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`;
+      return `token ${i} in ${path4} 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`;
+        return `Path ${path4} cannot use a regular expression wildcard`;
       }
       if (token.prefix !== "/") {
-        return `Wildcard :${token.name} must be immediately after a / in ${path3}`;
+        return `Wildcard :${token.name} must be immediately after a / in ${path4}`;
       }
       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 `Modifier ${token.modifier} is not allowed on wildcard :${token.name} in ${path4}. Modifiers are only allowed in the last path component`;
       }
     }
   }
@@ -1237,11 +1234,10 @@ var validateOptions = (options) => {
 // src/config/utils/convert.ts
 function convertV1RoutingToV2Routing(routing) {
   return routing.matches.map((group) => {
-    var _a, _b;
+    var _a;
     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
     };
   });
@@ -1478,22 +1474,22 @@ var validateConfigPaths = (applicationConfigsById) => {
       continue;
     }
     for (const pathMatch of app.routing) {
-      for (const path3 of pathMatch.paths) {
-        const tokens = (0, import_path_to_regexp2.parse)(path3);
+      for (const path4 of pathMatch.paths) {
+        const tokens = (0, import_path_to_regexp2.parse)(path4);
         for (const token of tokens.slice(0, -1)) {
           if (typeof token !== "string") {
             errors.push(
-              `Path ${path3} may only have a :wildcard in the last path component`
+              `Path ${path4} may only have a :wildcard in the last path component`
             );
           }
         }
-        const existing = pathsByApplicationId.get(path3);
+        const existing = pathsByApplicationId.get(path4);
         if (existing) {
           existing.applications.push(id);
         } else {
-          pathsByApplicationId.set(path3, {
+          pathsByApplicationId.set(path4, {
             applications: [id],
-            matcher: (0, import_path_to_regexp2.pathToRegexp)(path3),
+            matcher: (0, import_path_to_regexp2.pathToRegexp)(path4),
             applicationId: id
           });
         }
@@ -1501,10 +1497,10 @@ var validateConfigPaths = (applicationConfigsById) => {
     }
   }
   const entries = Array.from(pathsByApplicationId.entries());
-  entries.forEach(([path3, { applications: ids, matcher, applicationId }]) => {
+  entries.forEach(([path4, { applications: ids, matcher, applicationId }]) => {
     if (ids.length > 1) {
       errors.push(
-        `Duplicate path "${path3}" for applications "${ids.join(", ")}"`
+        `Duplicate path "${path4}" for applications "${ids.join(", ")}"`
       );
     }
     entries.forEach(
@@ -1512,14 +1508,14 @@ var validateConfigPaths = (applicationConfigsById) => {
         matchPath,
         { applications: matchIds, applicationId: matchApplicationId }
       ]) => {
-        if (path3 === matchPath) {
+        if (path4 === matchPath) {
           return;
         }
         if (applicationId === matchApplicationId) {
           return;
         }
         if (matcher.test(matchPath)) {
-          const source = `"${path3}" of application${ids.length > 0 ? "s" : ""} ${ids.join(", ")}`;
+          const source = `"${path4}" 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}`
@@ -1794,21 +1790,21 @@ var MicrofrontendConfigClient = class {
   isEqual(other) {
     return JSON.stringify(this.applications) === JSON.stringify(other.applications);
   }
-  getApplicationNameForPath(path3) {
-    if (!path3.startsWith("/")) {
+  getApplicationNameForPath(path4) {
+    if (!path4.startsWith("/")) {
       throw new Error(`Path must start with a /`);
     }
-    if (this.pathCache[path3]) {
-      return this.pathCache[path3];
+    if (this.pathCache[path4]) {
+      return this.pathCache[path4];
     }
-    const pathname = new URL(path3, "https://example.com").pathname;
+    const pathname = new URL(path4, "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_regexp3.pathToRegexp)(childPath);
             if (regexp.test(pathname)) {
-              this.pathCache[path3] = name;
+              this.pathCache[path4] = name;
               return name;
             }
           }
@@ -1821,7 +1817,7 @@ var MicrofrontendConfigClient = class {
     if (!defaultApplication) {
       return null;
     }
-    this.pathCache[path3] = defaultApplication[0];
+    this.pathCache[path4] = defaultApplication[0];
     return defaultApplication[0];
   }
   serialize() {
@@ -2089,14 +2085,14 @@ var MicrofrontendMainConfig = class extends MicrofrontendConfigIsomorphic {
   }
 };
 
-// src/config-v2/microfrontends/util/is-main-config.ts
+// src/config-v2/microfrontends/utils/is-main-config.ts
 function isMainConfig2(c) {
   return !("partOf" in c);
 }
 
 // src/config-v2/microfrontends/server/index.ts
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path4 = require("path");
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path6 = require("path");
 
 // src/config-v2/microfrontends-config/isomorphic/child.ts
 var MicrofrontendChildConfig = class extends MicrofrontendConfigIsomorphic {
@@ -2139,6 +2135,80 @@ var Microfrontends = class {
   }
 };
 
+// src/config-v2/microfrontends/utils/find-repository-root.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var GIT_DIRECTORY = ".git";
+function findRepositoryRoot(startDir) {
+  let currentDir = startDir || process.cwd();
+  while (currentDir !== import_node_path4.default.parse(currentDir).root) {
+    const gitPath = import_node_path4.default.join(currentDir, GIT_DIRECTORY);
+    if (import_node_fs3.default.existsSync(gitPath) && import_node_fs3.default.statSync(gitPath).isDirectory()) {
+      return currentDir;
+    }
+    currentDir = import_node_path4.default.dirname(currentDir);
+  }
+  throw new Error(
+    "Repository root not found. Specify the root of the repository with the `repository.root` option."
+  );
+}
+
+// src/config-v2/microfrontends/utils/find-package-path.ts
+var import_node_path5 = require("path");
+var import_node_fs4 = require("fs");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var configCache = {};
+function findPackagePathWithGlob({
+  repositoryRoot,
+  name
+}) {
+  try {
+    const packageJsonPaths = import_fast_glob.default.globSync("**/package.json", {
+      cwd: repositoryRoot,
+      absolute: true,
+      onlyFiles: true,
+      followSymbolicLinks: false,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    });
+    const matchingPaths = [];
+    for (const packageJsonPath2 of packageJsonPaths) {
+      const packageJsonContent = (0, import_node_fs4.readFileSync)(packageJsonPath2, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      if (packageJson.name === name) {
+        matchingPaths.push(packageJsonPath2);
+      }
+    }
+    if (matchingPaths.length > 1) {
+      throw new Error(
+        `Found multiple packages with the name "${name}" in the repository: ${matchingPaths.join(", ")}`
+      );
+    }
+    if (matchingPaths.length === 0) {
+      throw new Error(
+        `Could not find package with the name "${name}" in the repository`
+      );
+    }
+    const [packageJsonPath] = matchingPaths;
+    return (0, import_node_path5.dirname)(packageJsonPath);
+  } catch (error) {
+    return null;
+  }
+}
+function findPackagePath(opts) {
+  const cacheKey = `${opts.repositoryRoot}-${opts.name}`;
+  if (configCache[cacheKey]) {
+    return configCache[cacheKey];
+  }
+  const result = findPackagePathWithGlob(opts);
+  if (!result) {
+    throw new Error(
+      `Could not find package with the name "${opts.name}" in the repository`
+    );
+  }
+  configCache[cacheKey] = result;
+  return result;
+}
+
 // src/config-v2/microfrontends/server/validation.ts
 var import_jsonc_parser3 = require("jsonc-parser");
 var import_ajv2 = require("ajv");
@@ -2354,10 +2424,6 @@ var schema_v2_default = {
           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: {
@@ -2434,8 +2500,8 @@ var MicrofrontendsServer = class extends Microfrontends {
     pretty: true
   }) {
     const outputPath = getOutputFilePath();
-    import_node_fs3.default.mkdirSync((0, import_node_path4.dirname)(outputPath), { recursive: true });
-    import_node_fs3.default.writeFileSync(
+    import_node_fs5.default.mkdirSync((0, import_node_path6.dirname)(outputPath), { recursive: true });
+    import_node_fs5.default.writeFileSync(
       outputPath,
       JSON.stringify(
         this.config.toSchemaJson(),
@@ -2503,12 +2569,32 @@ var MicrofrontendsServer = class extends Microfrontends {
   static fromFile({
     filePath,
     cookies,
-    meta
+    meta,
+    options
   }) {
     try {
-      const config = import_node_fs3.default.readFileSync(filePath, "utf-8");
+      const configJson = import_node_fs5.default.readFileSync(filePath, "utf-8");
+      const config = MicrofrontendsServer.validate(configJson);
+      if (!isMainConfig(config) && (options == null ? void 0 : options.resolveMainConfig)) {
+        const repositoryRoot = findRepositoryRoot();
+        const packagePath = findPackagePath({
+          repositoryRoot,
+          name: config.partOf
+        });
+        if (!packagePath) {
+          throw new MicrofrontendError2(
+            `Could not find default application "${config.partOf}" in the repository`,
+            { type: "config", subtype: "not_found" }
+          );
+        }
+        const mainConfigPath = (0, import_node_path6.join)(packagePath, "microfrontends.json");
+        return MicrofrontendsServer.fromMainConfigFile({
+          filePath: mainConfigPath,
+          overrides: cookies ? parseOverrides(cookies) : void 0
+        });
+      }
       return new MicrofrontendsServer({
-        config: MicrofrontendsServer.validate(config),
+        config,
         overrides: cookies ? parseOverrides(cookies) : void 0,
         meta
       });
@@ -2526,7 +2612,7 @@ var MicrofrontendsServer = class extends Microfrontends {
     overrides
   }) {
     try {
-      const config = import_node_fs3.default.readFileSync(filePath, "utf-8");
+      const config = import_node_fs5.default.readFileSync(filePath, "utf-8");
       const validatedConfig = MicrofrontendsServer.validate(config);
       if (!isMainConfig(validatedConfig)) {
         throw new MicrofrontendError2(
@@ -2660,7 +2746,7 @@ var LocalProxy = class {
     const isJWTRedirect = url.searchParams.has("_vercel_jwt");
     const defaultHost = this.getDefaultHost(config);
     let hostname = null;
-    let path3 = request2.url;
+    let path4 = request2.url;
     if (isAuthRedirect) {
       hostname = url.searchParams.get("_host_override");
     }
@@ -2670,12 +2756,12 @@ var LocalProxy = class {
     if (isJWTRedirect) {
       hostname = url.searchParams.get("_host_override");
       url.searchParams.delete("_host_override");
-      path3 = `${url.pathname}${url.search}`;
+      path4 = `${url.pathname}${url.search}`;
     }
     if (!hostname) {
       return void 0;
     }
-    return { ...defaultHost, path: path3, hostname, protocol: "https", port: 443 };
+    return { ...defaultHost, path: path4, hostname, protocol: "https", port: 443 };
   }
   getConfigWithOverrides(cookies) {
     if (isV2Config(this.config)) {
@@ -2706,19 +2792,19 @@ var LocalProxy = class {
   getTarget(request2) {
     const cookies = (0, import_cookie.parse)(request2.headers.cookie || "");
     const config = this.getConfigWithOverrides(cookies);
-    const path3 = request2.url;
-    if (!path3) {
+    const path4 = request2.url;
+    if (!path4) {
       return this.getDefaultHost(config);
     }
     const authTarget = this.getAuthTarget(request2, config);
     if (authTarget) {
       return authTarget;
     }
-    const url = new URL(`http://example.com${path3}`);
+    const url = new URL(`http://example.com${path4}`);
     const pathname = url.pathname;
     if (isV2Config(config)) {
       const target = this.findMatchingApplicationV2(
-        path3,
+        path4,
         pathname,
         config.getChildApplications()
       );
@@ -2726,7 +2812,7 @@ var LocalProxy = class {
         return target;
     } else {
       const target = this.findMatchingApplicationV1(
-        path3,
+        path4,
         pathname,
         config.getAllApplications()
       );
@@ -2735,11 +2821,11 @@ var LocalProxy = class {
     }
     const defaultHost = this.getDefaultHost(config);
     mfeDebug(
-      `no matching routes, routing ${path3} to default application: ${JSON.stringify(defaultHost)}`
+      `no matching routes, routing ${path4} to default application: ${JSON.stringify(defaultHost)}`
     );
-    return { path: path3, ...defaultHost };
+    return { path: path4, ...defaultHost };
   }
-  findMatchingApplicationV1(path3, pathname, applications) {
+  findMatchingApplicationV1(path4, pathname, applications) {
     for (const application of Object.values(applications)) {
       if (application.routing) {
         for (const group of application.routing.matches) {
@@ -2748,9 +2834,9 @@ var LocalProxy = class {
             if (regexp.test(pathname)) {
               const target = this.getApplicationTarget(application);
               mfeDebug(
-                `routing ${path3} to '${target.application}' at ${target.hostname}`
+                `routing ${path4} to '${target.application}' at ${target.hostname}`
               );
-              return { path: path3, ...target };
+              return { path: path4, ...target };
             }
           }
           if (application.routing.assetPrefix) {
@@ -2760,9 +2846,9 @@ var LocalProxy = class {
             if (pattern.test(pathname)) {
               const target = this.getApplicationTarget(application);
               mfeDebug(
-                `routing ${path3} to '${target.application}' at ${target.hostname}`
+                `routing ${path4} to '${target.application}' at ${target.hostname}`
               );
-              return { path: path3, ...target };
+              return { path: path4, ...target };
             }
           }
         }
@@ -2770,7 +2856,7 @@ var LocalProxy = class {
     }
     return null;
   }
-  findMatchingApplicationV2(path3, pathname, applications) {
+  findMatchingApplicationV2(path4, pathname, applications) {
     for (const application of Object.values(applications)) {
       for (const group of application.routing) {
         for (const childPath of group.paths) {
@@ -2778,9 +2864,9 @@ var LocalProxy = class {
           if (regexp.test(pathname)) {
             const target = this.getApplicationTarget(application);
             mfeDebug(
-              `routing ${path3} to '${target.application}' at ${target.hostname}`
+              `routing ${path4} to '${target.application}' at ${target.hostname}`
             );
-            return { path: path3, ...target };
+            return { path: path4, ...target };
           }
         }
       }
@@ -2789,11 +2875,11 @@ var LocalProxy = class {
   }
   // Handles requests that return data from the local proxy itself.
   // Returns true if the request was handled, false otherwise.
-  handleProxyInfoRequest(path3, res) {
-    if (!path3) {
+  handleProxyInfoRequest(path4, res) {
+    if (!path4) {
       return false;
     }
-    const url = new URL(`http://example.comf${path3}`);
+    const url = new URL(`http://example.comf${path4}`);
     const pathname = url.pathname;
     switch (pathname) {
       case "/.well-known/vercel/microfrontend-routing": {
@@ -2821,10 +2907,10 @@ var LocalProxy = class {
     }
     const target = this.getTarget(req);
     if (target.protocol === "https") {
-      const { hostname, port, path: path3 } = target;
+      const { hostname, port, path: path4 } = target;
       const requestOptions = {
         hostname,
-        path: path3,
+        path: path4,
         method: req.method,
         headers: {
           ...req.headers,
@@ -2852,7 +2938,7 @@ var LocalProxy = class {
         console.error("Proxy request error: ", err);
         res.writeHead(500, { "Content-Type": "text/plain" });
         res.end(
-          `Error proxying request for ${target.application} to ${hostname}:${port}${path3}`
+          `Error proxying request for ${target.application} to ${hostname}:${port}${path4}`
         );
       });
     } else {

package/dist/config/client.d.ts

@@ -1,4 +1,4 @@
-import { A as ApplicationConfig, C as Config } from '../schema-83a75e61.js';
+import { A as ApplicationConfig, C as Config } from '../schema-2922d49e.js';
 
 type ClientApplicationConfig = Pick<ApplicationConfig, 'default' | 'routing'>;
 interface ClientConfig {

package/dist/config/edge.d.ts

@@ -1,5 +1,5 @@
-export { C as MicrofrontendSchema } from '../schema-83a75e61.js';
-import { a as MicrofrontendConfigCommon } from '../microfrontend-config-2425db74.js';
+export { C as MicrofrontendSchema } from '../schema-2922d49e.js';
+import { a as MicrofrontendConfigCommon } from '../microfrontend-config-983a5139.js';
 
 /**
  * Edge Runtime does not support ajv validation, or fs access.

package/dist/config.cjs

@@ -765,10 +765,6 @@ var schema_default = {
             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."
             }
           }
         },
@@ -1129,11 +1125,10 @@ var validateOptions = (options) => {
 // src/config/utils/convert.ts
 function convertV1RoutingToV2Routing(routing) {
   return routing.matches.map((group) => {
-    var _a, _b;
+    var _a;
     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
     };
   });