@modern-js/main-doc 3.0.0-alpha.0 → 3.0.0-alpha.1

package/docs/en/apis/app/commands.mdx

@@ -19,7 +19,6 @@ Options:
   -e --entry <entry>    compiler by entry
   -c --config <config>  specify the configuration file, which can be a relative or absolute path
   -h, --help            show command help
-  --analyze             analyze the bundle and view size of each module
   --web-only            only start web service
   --api-only            only start API service
 ```
@@ -79,31 +78,8 @@ Options:
   -c --config <config>  specify the configuration file, which can be a relative or absolute path
   -h, --help            show command help
   -w --watch            turn on watch mode, watch for changes and rebuild
-  --analyze             analyze the bundle and view size of each module
 ```
 
-### Analyze Bundle
-
-execute `npx modern build --analyze` command, can produce an HTML file that analyzes the volume of the bundle while packaging the production code:
-
-```text
-Bundle Analyzer saved report to /example/dist/report.html
-
-info    Production file sizes:
-
-  File                                      Size         Gzipped
-  dist/static/js/lib-react.09721b5c.js      152.6 kB     49.0 kB
-  dist/html/main/index.html                 5.8 kB       2.5 kB
-  dist/static/js/main.3568a38e.js           3.5 kB       1.4 kB
-  dist/static/css/main.03221f72.css         1.4 kB       741 B
-```
-
-Open the above HTML file in the browser, you can see the tile diagram of the bundled files, and perform package volume analysis and optimization:
-
-<img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/aphqeh7uhohpquloj/modern-js/mwa-build-analyze-8784f762c1ab0cb20935829d5f912c4c.png" />
-
-> this features based on [webpack-bundle-analyzer](https://github.com/webpack-contrib/webpack-bundle-analyzer).
-
 ## modern new
 
 The `modern new` command is used to enable features in an existing project.
@@ -174,7 +150,7 @@ Options:
 
 ## modern inspect
 
-The `modern inspect` command is used to view the Modern.js config, [Rsbuild config](https://rsbuild.rs/config/index) and webpack or Rspack config of the project.
+The `modern inspect` command is used to view the Modern.js config, [Rsbuild config](https://rsbuild.rs/config/index) and Rspack config of the project.
 
 ```bash
 Usage: modern inspect [options]
@@ -191,7 +167,7 @@ After executing the command `npx modern inspect` in the project root directory,
 
 - `modern.js.config.mjs`:The Modern.js configuration currently used.
 - `rsbuild.config.mjs`: The Rsbuild config to use at build time.
-- `webpack.config.web.mjs`: The webpack config used by to use at build time.
+- `rspack.config.web.mjs`: The Rspack config used by to use at build time.
 
 ```bash
 ➜ npx modern inspect
@@ -199,7 +175,7 @@ After executing the command `npx modern inspect` in the project root directory,
 Inspect config succeed, open following files to view the content:
 
   - Rsbuild Config: /root/my-project/dist/rsbuild.config.mjs
-  - Webpack Config (web): /root/my-project/dist/webpack.config.web.mjs
+  - Rspack Config (web): /root/my-project/dist/rspack.config.web.mjs
   - Modern.js Config: /root/my-project/dist/modern.js.config.mjs
 ```
 
@@ -221,7 +197,7 @@ modern inspect --verbose
 
 ### SSR Configuration
 
-If the project has enabled SSR, an additional `webpack.config.node.mjs` file will be generated in the `dist/`, corresponding to the webpack configuration at SSR build time.
+If the project has enabled SSR, an additional `rspack.config.node.mjs` file will be generated in the `dist/`, corresponding to the Rspack configuration at SSR build time.
 
 ```bash
 ➜ npx modern inspect
@@ -229,8 +205,8 @@ If the project has enabled SSR, an additional `webpack.config.node.mjs` file wil
 Inspect config succeed, open following files to view the content:
 
   - Rsbuild Config: /root/my-project/dist/rsbuild.config.mjs
-  - Webpack Config (web): /root/my-project/dist/webpack.config.web.mjs
-  - Webpack Config (node): /root/my-project/dist/webpack.config.node.mjs
+  - Rspack Config (web): /root/my-project/dist/rspack.config.web.mjs
+  - Rspack Config (node): /root/my-project/dist/rspack.config.node.mjs
   - Modern.js Config: /root/my-project/dist/modern.js.config.mjs
 ```
 

package/docs/en/components/bff-upload.mdx

@@ -1,11 +1,9 @@
-BFF combined with runtime framework provides file upload capabilities, supporting integrated calls and pure function manual calls.
-
 ### BFF Function
 
 First, create the `api/lambda/upload.ts` file:
 
 ```ts title="api/lambda/upload.ts"
-export const post = async ({ formData }: {formData: Record<string, any>}) => {
+export const post = async ({ formData }: { formData: Record<string, any> }) => {
   console.info('formData:', formData);
   // do somethings
   return {
@@ -15,11 +13,11 @@ export const post = async ({ formData }: {formData: Record<string, any>}) => {
   };
 };
 ```
+
 :::tip
 The `formData` parameter in the interface processing function can access files uploaded from the client side. It is an `Object` where the keys correspond to the field names used during the upload.
 :::
 
-
 ### Integrated Calling
 
 Next, directly import and call the function in `src/routes/upload/page.tsx`:
@@ -61,8 +59,8 @@ export default (): JSX.Element => {
 Note: The input parameter type must be `{ formData: FormData }` for the upload to succeed.
 :::
 
-
 ### Manual Calling
+
 You can manually upload files using the `fetch API`, when calling `fetch`, set the `body` as `FormData` type and submit a post request.
 
 ```tsx title="routes/upload/page.tsx"

package/docs/en/components/bundler.mdx

@@ -1,3 +1,3 @@
-Refers to module bundlers such as [webpack](https://webpack.js.org/), [Rspack](https://rspack.rs/).
+Refers to module bundlers such as [Rspack](https://rspack.rs/).
 
 The main goal of bundlers is to bundle JavaScript, CSS and other files together, and the bundled files can be used in the browser, Node.js or other environments. When bundler processes the Web application, it builds a dependency graph and then combines every module into one or more bundles.

package/docs/en/components/enable-bff.mdx

@@ -23,7 +23,7 @@ pnpm add @modern-js/plugin-bff@<version>
 
 :::
 
-2. Configure modern.config.ts
+2. Configure `modern.config.ts`
 
 Import and add the BFF plugin in the `modern.config.[tj]s` file:
 
@@ -47,6 +47,10 @@ To correctly recognize the `@api` alias in TypeScript, it is recommended to add
       ..., // other paths,
       "@api/*": ["./api/lambda/*"]
     }
-  }
+  },
+  "include": [
+    ..., // other include directories
+    "api"  // Add api directory
+  ]
 }
 ```

package/docs/en/components/enable-ssg.mdx

@@ -9,6 +9,7 @@ pnpm add @modern-js/plugin-ssg
 ```
 
 :::tip Version Consistency
+
 Make sure the version of `@modern-js/plugin-ssg` matches the version of `@modern-js/app-tools` in your project. All Modern.js official packages are released with a uniform version number, and version mismatches may cause compatibility issues.
 
 Check the version of `@modern-js/app-tools` first, then install the same version of `@modern-js/plugin-ssg`:

package/docs/en/components/esbuild.mdx

@@ -1,3 +1,3 @@
-[esbuild](https://esbuild.github.io/) is a front-end build tool based on Golang. It has the functions of bundling, compiling and minimizing JavaScript code. Compared with traditional tools, the performance is significantly improved. When minimizing code, compared to webpack's built-in terser minimizer, esbuild has dozens of times better performance.
+[esbuild](https://esbuild.github.io/) is a front-end build tool based on Golang. It has the functions of bundling, compiling and minimizing JavaScript code. Compared with traditional tools, the performance is significantly improved. When minimizing code, esbuild has dozens of times better performance.
 
-Modern.js provides esbuild plugin that allow you to use esbuild instead of babel-loader, ts-loader and terser for transformation and minification process. When you enable esbuild in a large project, **it can greatly reduce the time required for code compilation and compression, while effectively avoiding OOM (heap out of memory) problems**.
+Modern.js provides esbuild plugin that allow you to use esbuild instead of babel-loader, ts-loader for transformation and minification process. When you enable esbuild in a large project, **it can greatly reduce the time required for code compilation and compression, while effectively avoiding OOM (heap out of memory) problems**.

package/docs/en/components/extend-bff-function.mdx

@@ -1,5 +1,3 @@
-The standard BFF function writing method may not always meet your needs. We are designing a more powerful BFF function writing method to allow developers to extend BFF functions more conveniently.
+The standard BFF function writing method may not always meet your needs. For example, complex TS type requirements in business scenarios. EdenX provides a more powerful BFF function writing method.
 
-:::note
-Coming soon
-:::
+For more details, please refer to - [Creating Extensible BFF Functions](/guides/advanced-features/bff/operators).

package/docs/en/components/hono.mdx

@@ -0,0 +1,119 @@
+### Getting Request Context
+
+Sometimes in BFF functions, it's necessary to obtain the request context to handle more logic. In such cases, you can use `useHonoContext` to get it:
+
+```ts title="api/lambda/hello.ts"
+import { useHonoContext } from '@modern-js/plugin-bff/server';
+
+export const get = async () => {
+  const c = useHonoContext();
+  console.info(`access url: ${c.req.url}`);
+  return 'Hello Modern.js';
+};
+```
+
+:::info
+For more details, refer to [useHonoContext](/apis/app/runtime/bff/use-hono-context).
+:::
+
+### Getting Cookies
+
+When getting cookies in BFF functions, you need to get the request context through `useHonoContext`, then use `c.req.header('cookie')` to get the Cookie string and parse it manually:
+
+```ts title="api/lambda/cookies.ts"
+import { Api, Get, useHonoContext } from '@modern-js/plugin-bff/server';
+
+// Helper function to parse Cookie string
+function parseCookies(
+  cookieHeader: string | undefined,
+): Record<string, string> {
+  const cookies: Record<string, string> = {};
+  if (!cookieHeader) return cookies;
+
+  cookieHeader.split(';').forEach(cookie => {
+    const [name, ...rest] = cookie.trim().split('=');
+    if (name) {
+      cookies[name] = rest.join('=');
+    }
+  });
+
+  return cookies;
+}
+
+export const getCookies = Api(Get('/cookies'), async () => {
+  const c = useHonoContext();
+  const cookieHeader = c.req.header('cookie');
+  const cookies = parseCookies(cookieHeader);
+  const token = cookies.token;
+  const sessionId = cookies.sessionId;
+  return {
+    hasToken: !!token,
+    token: token || null,
+    sessionId: sessionId || null,
+  };
+});
+```
+
+:::caution Note
+The `c.req.cookie()` method does not exist in the current version. You need to use `c.req.header('cookie')` to get the Cookie string and parse it manually.
+:::
+
+### Defining BFF Functions
+
+When using Hono as the runtime framework, you can define interfaces through [Api functions](/guides/advanced-features/bff/operators.html):
+
+```ts title="api/lambda/user.ts"
+import { Api, Get, Query } from '@modern-js/plugin-bff/server';
+import { z } from 'zod';
+
+const QuerySchema = z.object({
+  id: z.string(),
+});
+
+export const getUser = Api(
+  Get('/user'),
+  Query(QuerySchema),
+  async ({ query }) => {
+    return {
+      id: query.id,
+      name: 'Modern.js',
+      email: 'modernjs@bytedance.com',
+    };
+  },
+);
+```
+
+:::info
+For more details about Api functions and operators, refer to [Creating Extensible BFF Functions](/guides/advanced-features/bff/operators.html).
+:::
+
+### Using Middleware
+
+Hono supports a rich middleware ecosystem, and you can use middleware in BFF functions:
+
+```ts title="api/lambda/user.ts"
+import { Api, Get, Middleware } from '@modern-js/plugin-bff/server';
+
+export const getUser = Api(
+  Get('/user'),
+  Middleware(async (c, next) => {
+    // You can access Hono's Context in middleware
+    c.res.headers.set('X-Powered-By', 'Modern.js');
+    await next();
+  }),
+  async () => {
+    return {
+      name: 'Modern.js',
+      email: 'modernjs@bytedance.com',
+    };
+  },
+);
+```
+
+:::info
+For more details about middleware, refer to [Creating Extensible BFF Functions](/guides/advanced-features/bff/operators.html#middleware).
+:::
+
+### More Hono Documentation
+
+For more detailed information about Hono, please refer to the [Hono official documentation](https://hono.dev/).

package/docs/en/components/international/custom-instance-code.mdx

@@ -0,0 +1,16 @@
+```ts
+import { defineRuntimeConfig } from '@modern-js/runtime';
+import i18next from 'i18next';
+
+// Create custom instance
+const customI18n = i18next.createInstance({
+  // Custom configuration
+});
+
+export default defineRuntimeConfig({
+  i18n: {
+    i18nInstance: customI18n,
+  },
+});
+```
+

package/docs/en/components/international/init-options-desc.mdx

@@ -0,0 +1 @@
+`initOptions` will be passed to i18next's `init` method and supports all i18next configuration options:

package/docs/en/components/international/install-command.mdx

@@ -2,8 +2,22 @@
 pnpm add @modern-js/plugin-i18n i18next react-i18next
 ```
 
+:::tip Version Consistency
+Make sure the version of `@modern-js/plugin-i18n` matches the version of `@modern-js/app-tools` in your project. All Modern.js official packages are released with a uniform version number, and version mismatches may cause compatibility issues.
+
+Check the version of `@modern-js/app-tools` first, then install the same version of `@modern-js/plugin-i18n`:
+
+```bash
+# Check the current version of @modern-js/app-tools
+pnpm list @modern-js/app-tools
+
+# Install the same version of @modern-js/plugin-i18n
+pnpm add @modern-js/plugin-i18n@<version> i18next react-i18next
+```
+
+:::
+
 :::info
 `i18next` and `react-i18next` are peer dependencies and need to be installed manually.
 
 :::
-

package/docs/en/components/international/instance-code.mdx

@@ -0,0 +1,26 @@
+Create the `src/modern.runtime.ts` file and configure i18n runtime options:
+
+```ts
+import { defineRuntimeConfig } from '@modern-js/runtime';
+import i18next from 'i18next';
+
+// It's recommended to create a new i18next instance to avoid using the global default instance
+const i18nInstance = i18next.createInstance();
+
+export default defineRuntimeConfig({
+  i18n: {
+    i18nInstance: i18nInstance,
+    initOptions: {
+      fallbackLng: 'en',
+      supportedLngs: ['zh', 'en'],
+    },
+  },
+});
+```
+
+:::info
+`modern.runtime.ts` is a runtime configuration file used to configure i18next initialization options. Even for the most basic configuration, it's recommended to create this file to ensure the plugin works correctly.
+
+It's recommended to use `i18next.createInstance()` to create a new instance instead of directly using the default exported `i18next`. This avoids global state pollution and ensures each application has an independent i18n instance.
+
+:::

package/docs/en/configure/app/builder-plugins.mdx

@@ -16,8 +16,7 @@ Rsbuild is the build tool of Modern.js, please read [Build Engine](/guides/conce
 This option **is used to configure the Rsbuild plugins**. If you need to configure other types of plugins, please select the corresponding configs:
 
 - Use [plugins](/configure/app/plugins) to configure Modern.js framework plugins.
-- Use [tools.bundlerChain](/configure/app/tools/bundler-chain) to configure Rspack or webpack plugins.
-- Use [tools.babel](/configure/app/tools/babel) to configure Babel plugins.
+- Use [tools.bundlerChain](/configure/app/tools/bundler-chain) to configure Rspack plugins.
 
 ## When to use
 

package/docs/en/configure/app/dev/server.mdx

@@ -101,3 +101,111 @@ const defaultOptions = {
 ```
 
 For more configuration options and detailed usage, please refer to the [Rsbuild - server.cors](https://rsbuild.rs/config/server/cors) documentation.
+
+### proxy
+
+- **Type:** `Record<string, string> | Record<string, ProxyDetail>`
+- **Default:** `undefined`
+
+Proxy requests to the specified service.
+
+```js
+export default {
+  dev: {
+    server: {
+      proxy: {
+        '/api': 'http://localhost:3000',
+      },
+    },
+  },
+};
+```
+
+At this point, the /api/users request will be proxied to http://localhost:3000/api/users.
+
+If you don't want to pass /api, you can rewrite the request path through `pathRewrite`:
+
+```js
+export default {
+  dev: {
+    server: {
+      proxy: {
+        '/api': {
+          target: 'http://localhost:3000',
+          pathRewrite: { '^/api': '' },
+        },
+      },
+    },
+  },
+};
+```
+
+DevServer Proxy is implemented based on [http-proxy-middleware](https://github.com/chimurai/http-proxy-middleware/tree/2.x). You can use all configuration items of http-proxy-middleware, see the documentation for details.
+
+The full type definition of DevServer Proxy is:
+
+```ts
+import type { Options as HttpProxyOptions } from 'http-proxy-middleware';
+
+type Filter = string | string[] | ((pathname: string, req: Request) => boolean);
+
+type ProxyDetail = HttpProxyOptions & {
+  bypass?: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    proxyOptions: ProxyOptions,
+  ) => string | undefined | null | false;
+  context?: Filter;
+};
+
+type ProxyOptions =
+  | Record<string, string>
+  | Record<string, ProxyDetail>
+  | ProxyDetail[]
+  | ProxyDetail;
+```
+
+In addition to the http-proxy-middleware options, two configuration items are also supported: bypass and context:
+
+- bypass: Bypass the proxy based on the return value of the function.
+  - Returning `null` or `undefined` will continue to process the request with proxy.
+  - Returning `false` will return a 404 error.
+  - Returning a specific service path will use this path to replace the original request path.
+- context: If you want to proxy multiple specific paths to the same target, you can use the context configuration item.
+
+```js
+// Custom bypass method
+export default {
+  dev: {
+    server: {
+      proxy: {
+        '/api': {
+          target: 'http://localhost:3000',
+          bypass: function (req, res, proxyOptions) {
+            if (req.headers.accept.indexOf('html') !== -1) {
+              console.log('Skipping proxy for browser request.');
+              return '/index.html';
+            }
+          },
+        },
+      },
+    },
+  },
+};
+```
+
+```js
+// Proxy multiple paths to the same target
+export default {
+  dev: {
+    server: {
+      proxy: [
+        {
+          context: ['/auth', '/api'],
+          target: 'http://localhost:3000',
+        },
+      ],
+    },
+  },
+};
+```

package/docs/en/configure/app/experiments/source-build.mdx

@@ -4,7 +4,6 @@ title: sourceBuild
 
 - **Type:** `boolean | PluginSourceBuildOptions`
 - **Default:** `false`
-- **Version:** `MAJOR_VERSION.46.0`
 
 Used to enable the ability for source code building. When this configuration option is enabled, Modern.js will read the source code files corresponding to the `source` field in the sub-project's package.json and compile them.
 

package/docs/en/configure/app/output/assets-retry.mdx

@@ -31,7 +31,7 @@ export type AssetsRetryOptions = {
 
 - **Default:** `undefined`
 
-- Since this feature injects some runtime code into your HTML and [webpack/Rspack Runtime](https://rspack.rs/api/runtime-api/module-variables), it is disabled by default. To enable it, provide an object for the option, for example:
+- Since this feature injects some runtime code into your HTML and [Rspack Runtime](https://rspack.rs/api/runtime-api/module-variables), it is disabled by default. To enable it, provide an object for the option, for example:
 
 ```js
 export default {

package/docs/en/configure/app/output/disable-inline-runtime-chunk.mdx

@@ -10,9 +10,9 @@ title: disableInlineRuntimeChunk
 Used to control whether to inline the bundler's runtime code into HTML.
 
 :::tip What is runtimeChunk
-Modern.js will generate a `builder-runtime.js` file in the dist directory, which is the runtime code of webpack or Rspack.
+Modern.js will generate a `builder-runtime.js` file in the dist directory, which is the runtime code of Rspack.
 
-runtimeChunk is a piece of runtime code, which is provided by webpack or Rspack, that contains the necessary module processing logic, such as module loading, module parsing, etc. See [Runtime](https://webpack.js.org/concepts/manifest/#runtime) for details.
+runtimeChunk is a piece of runtime code, which is provided by Rspack, that contains the necessary module processing logic, such as module loading, module parsing, etc. See [Runtime Chunk](https://rspack.rs/config/optimization#optimizationruntimechunk) for details.
 
 :::
 

package/docs/en/configure/app/output/filename.mdx

@@ -2,16 +2,14 @@
 title: filename
 ---
 
+# output.filename
+
 :::warning
 
 In Modern.js `dev` command or use Modern.js server deployment, don't modify the html output filename. This will cause the page to be 404.
 
-In common, you don't need to modify the html filename. If you want modify `main.html` to `index.html`, using [source.mainEntryName](/configure/app/source/main-entry-name).
-
 :::
 
-# output.filename
-
 - **Type:**
 
 ```ts

package/docs/en/configure/app/output/temp-dir.mdx

@@ -7,7 +7,7 @@ title: tempDir
 - **Type:** `string`
 - **Default:** `''`
 
-When developing or building a project, Modern.js generates real Webpack entries and HTML templates, placing them in a temporary directory.
+When developing or building a project, Modern.js generates real Rspack entries and HTML templates, placing them in a temporary directory.
 
 If you want to start a project with multiple configurations at the same time, you can use this configuration to generate files in different temporary directories to avoid interference with each other.
 
@@ -19,6 +19,6 @@ Example:
 export default {
   output: {
     tempDir: path.join('node_modules', '.temp-dir'),
-  }
-}
+  },
+};
 ```

package/docs/en/configure/app/performance/build-cache.mdx

@@ -19,7 +19,7 @@ type BuildCacheConfig =
       cacheDigest?: Array<string | undefined>;
       /**
        * An arrays of additional code dependencies for the build.
-       * Rspack / webpack will use a hash of each of these items and all dependencies to invalidate the filesystem cache.
+       * Rspack will use a hash of each of these items and all dependencies to invalidate the filesystem cache.
        */
       buildDependencies?: string[];
     }

package/docs/en/configure/app/performance/profile.mdx

@@ -7,7 +7,7 @@ title: profile
 - **Type:** `boolean`
 - **Default:** `false`
 
-Whether capture timing information for each module, same as the [profile](https://webpack.js.org/configuration/other-options/#profile) config of Rspack.
+Whether capture timing information for each module, same as the [profile](https://rspack.rs/config/other-options#profile) config of Rspack.
 
 import RsbuildConfig from '@site-docs-en/components/rsbuild-config-tooltip';
 

package/docs/en/configure/app/plugins.mdx

@@ -10,11 +10,9 @@ Used to configure custom Modern.js framework CLI plugins. For information on how
 This option is **specifically for configuring framework CLI plugins**. If you need to configure other types of plugins, use the appropriate configuration method:
 
 - Use [builderPlugins](/configure/app/builder-plugins) for Rsbuild plugins.
-- Use [tools.bundlerChain](/configure/app/tools/bundler-chain) for Rspack or webpack plugins.
-- Use [tools.babel](/configure/app/tools/babel) for Babel plugins.
+- Use [tools.bundlerChain](/configure/app/tools/bundler-chain) for Rspack plugins.
 - Use the [plugins field in runtime config](/configure/app/runtime/plugins) for framework Runtime plugins.
 
-
 ## Examples
 
 Below are examples of using CLI plugins:

package/docs/en/configure/app/runtime/router.mdx

@@ -4,10 +4,6 @@ title: router
 
 # router
 
-import RouterLegacyTip from "@site-docs-en/components/router-legacy-tip"
-
-<RouterLegacyTip />
-
 - **Type:** `boolean | Object`
 - **Default:** `false`
 

package/docs/en/configure/app/security/sri.mdx

@@ -10,7 +10,6 @@ title: sri
 type SriOptions = {
   hashFuncNames?: [string, ...string[]];
   enabled?: 'auto' | true | false;
-  hashLoading?: 'eager' | 'lazy'; // only support webpack
 };
 ```
 

package/docs/en/configure/app/source/alias.mdx

@@ -12,7 +12,7 @@ type Alias = Record<string, string | false | (string | false)[]> | Function;
 
 - **Default:** `undefined`
 
-Create aliases to import or require certain modules, same as the [resolve.alias](https://webpack.js.org/configuration/resolve/#resolvealias) config of Rspack.
+Create aliases to import or require certain modules, same as the [resolve.alias](https://rspack.rs/config/resolve#resolvealias) config of Rspack.
 
 :::tip
 For TypeScript projects, you only need to configure [compilerOptions.paths](https://www.typescriptlang.org/tsconfig#paths) in the `tsconfig.json` file. The Rsbuild will automatically recognize it, so there is no need to configure the `source.alias` option separately. For more details, please refer to [Path Aliases](https://modernjs.dev/en/guides/basic-features/alias.html).

package/docs/en/configure/app/source/enable-async-entry.mdx

@@ -7,7 +7,7 @@ title: enableAsyncEntry
 - **Type:** `boolean`
 - **Default:** `false`
 
-This option is used for webpack Module Federation scenario.
+This option is used for Rspack Module Federation scenario.
 
 When this option is enabled, Modern.js will wrap the automatically generated entry files with dynamic import (Asynchronous Boundaries), allowing page code to consume remote modules generated by Module Federation.