@modern-js/main-doc 2.66.1-alpha.0 → 2.66.1-alpha.2

package/docs/en/apis/app/runtime/web-server/hook.mdx

@@ -6,6 +6,11 @@ title: Hook
 
 Used to extend Modern.js built-in Web Server, all page requests are handled by these hooks.
 
+:::warning
+It is recommended to use [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware) to handle page requests.
+
+:::
+
 :::note
 For more detail, see [Extend Web Server](/guides/advanced-features/web-server).
 

package/docs/en/apis/app/runtime/web-server/middleware.mdx

@@ -6,9 +6,9 @@ title: Middleware
 
 Used to extend the built-in Web Server of Modern.js, unlike [Hook](/apis/app/runtime/web-server/hook), Middleware can directly operate Node's origin request and response, and can be extended using the framework plugin.
 
-:::note
+:::warning
 
-In the next major release, Modern.js will use new middleware to replace this approach.
+Middleware will be removed in the next major version.
 
 It is recommended to use [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware) to handle page requests.
 
@@ -118,24 +118,3 @@ export const Middleware = () => async (ctx, next) => {
   ctx.response.locals.rpc = createRpcInstance();
 };
 ```
-
-### Framework Extension
-
-Middleware can also use runtime framework extensions like BFF.
-
-When using framework runtime extensions, type information is exported from `@modern-js/runtime/{namespace}`. Middleware can use framework syntax, such as framework middleware writing, the following is pseudo-code:
-
-```ts
-import { SomeType } from '@modern-js/runtime/{namespace}';
-
-export const middleware: SomeType = (ctx, next) => {
-  console.log(ctx.url);
-  next();
-};
-```
-
-By default, the framework extension capability of Web Server is turned off after installing the framework extension plugin. If you want to use the framework extension, you can turn it on through ['server.enableFrameworkExt'](/configure/app/server/enable-framework-ext.html).
-
-:::info
-The type name exported by the framework extension may not 'Middleware', but is named by the framework extension plugin.
-:::

package/docs/en/configure/app/runtime/0-intro.mdx

@@ -61,6 +61,10 @@ Using the `src/modern.runtime.ts` configuration approach does not support export
 Using the `src/modern.runtime.ts` configuration approach requires Modern.js version **MAJOR_VERSION.66.0** or higher.
 :::
 
+import RuntimeCliConfig from '@site-docs/components/runtime-cli-config';
+
+<RuntimeCliConfig />
+
 ## Configuration Evolution
 
 Before MAJOR_VERSION.66.0, runtime configurations were scattered across multiple locations:

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

@@ -2,7 +2,7 @@
 title: router
 ---
 
-# runtime.router
+# router
 
 import RouterLegacyTip from "@site-docs-en/components/router-legacy-tip"
 

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

@@ -2,7 +2,7 @@
 title: state
 ---
 
-# runtime.state
+# state
 
 - **Type:** `boolean | object`
 - **Default:** `false`

package/docs/en/guides/advanced-features/web-server.mdx

@@ -4,31 +4,21 @@ sidebar_position: 16
 
 # Custom Web Server
 
-As a client-centric development framework, Modern.js has limited customization capabilities on the server side. However, in some development scenarios, special server-level logic needs to be customized, such as user authentication, request preprocessing, and adding page rendering skeletons.
+Modern.js encapsulates most server-side capabilities required by projects, typically eliminating the need for server-side development. However, in certain scenarios such as user authentication, request preprocessing, or adding page skeletons, custom server-side logic may still be necessary.
 
-Some developers may be wondering, Modern.js already provides [BFF](/guides/advanced-features/bff/function.html), why you need **Custom Web Server**.
+Modern.js provides two types of APIs to extend the Web Server: **Middleware** and **Lifecycle Hooks**.
 
-The reason is that by default, page routing does not go through BFF, it has no way to provide server-side custom logic for page access. The reason for this design is that we do not want the service that controls the page to be bound to the BFF service, this is to avoid the BFF framework restricting how the page is deployed.
-
-For example, hosting pages separately from BFF, deploying page services to non-Node environments, customizing for deployment platforms, etc.
-
-For the above reasons, Modern.js provides three ways that projects can customize server-level capabilities progressively according to their needs.
-
-:::warning
-The three extension methods cannot work at the same time, and developers need to choose the appropriate method according to the scenario.
+:::note
+Middleware and Hooks only take effect when users request page routes, and BFF routes won't pass through these APIs.
 :::
 
-## Extending Web Server with API
+## Enabling Custom Web Server
 
-The first way is to customize the server-side at a specific lifecycle through the server-side runtime API provided by Modern.js. The purpose of providing this way is that in some cases, developers do not need to control the full Web Server, but only need to add server-level logic.
-
-Because the full web server cannot be controlled this way, and the extension logic **only takes effect when the page is requested**. Therefore, it is relatively simple to apply server-level logic, and you do not want to create additional BFFs or BFFs and pages without common server-level logic scenarios.
-
-You can run the'pnpm run new 'command in the project root directory to enable the "Custom Web Serve" function:
+Developers can execute the `pnpm run new` command in the project root directory to enable the "Custom Web Server" feature:
 
 ```bash
-? Please select the operation you want: Create Element
-? Please select the type of element to create: New "Custom Web Server" source code directory
+? Select operation: Create project element
+? Select element type: Create "Custom Web Server" source directory
 ```
 
 After executing the command, register the `@modern-js/plugin-server` plugin in `modern.config.ts`:
@@ -41,84 +31,19 @@ export default defineConfig({
 });
 ```
 
-After the function is turned on, the `server/index.ts` file will be automatically created in the project directory, and custom logic can be written in this file. Modern.js provides two types of APIs, **Hook** and **Middleware**, to extend Web Server.
-
-### Hook
-
-The Hook provided by Modern.js is used to control the built-in logic in the Web Server, and all page requests go through the Hook.
+Once enabled, a `server/index.ts` file will be automatically created in the project directory where custom logic can be implemented.
 
-Currently, two Hooks are provided: `AfterMatch` and `AfterRender`, which can be used to modify the rendering results. It can be written in `server/index.ts` as follows:
-
-```ts
-import type {
-  AfterMatchHook,
-  AfterRenderHook,
-} from '@modern-js/runtime/server';
-
-export const afterMatch: AfterMatchHook = (ctx, next) => {
-  next();
-};
-
-export const afterRender: AfterRenderHook = (ctx, next) => {
-  next();
-};
-```
-
-Projects should follow these best practices when using Hook:
-
-1. Authentication in afterMatch.
-2. Do Rewrite and Redirect in afterMatch.
-3. Inject HTML content in afterRender.
-
-:::note
-For more detail, see [Hook](/apis/app/runtime/web-server/hook).
-:::
-
-### Middleware
-
-For some projects, there may be more requirements at the server level, Modern.js provides Middleware to add pre-middleware for Web Server. It can only run in a Node environment, so if the project is deployed to another environment, such as a Worker environment, Middleware cannot be used.
-
-:::note
-In the next major release, Modern.js will use new middleware to replace this approach.
-
-It is recommended to use [UnstableMiddleware](/guides/advanced-features/web-server.html#unstablemiddleware) to handle page requests.
-:::
-
-Modern.js provides a set of APIs by default for projects to use:
-
-```ts
-import { Middleware } from '@modern-js/runtime/server';
-
-export const middleware: Middleware = (context, next) => {
-  const {
-    source: { req, res },
-  } = context;
-  console.log(req.url);
-  next();
-};
-```
-
-:::note
-For more detail, see [Middleware] (/apis/app/runtime/web-server/middleware).
-:::
-
-Projects should follow these best practices when using Middleware:
-
-1. In Middleware, you can directly operate origin request and response objects, do event tracking, and inject Node services (databases, Redis, etc.) that may be used for SSR rendering.
-2. Operations such as marking and crawler optimization can be done in Middleware.
-3. In Middleware, you can ignore the default rendering and customize the rendering process.
-
-**In general, in CSR projects, using Hook can basically meet all the needs of simple scenarios. In SSR projects, Middleware can be used for more complex Node extensions.**
+## Custom Web Server Capabilities
 
 ### Unstable Middleware
 
-Modern.js will provide new Middleware to add pre-processing middleware to the Web Server, supporting the execution of custom logic before and after handling the page.
+Modern.js supports adding rendering middleware to the Web Server, allowing custom logic execution before and after processing page routes.
 
 ```ts title="server/index.ts"
 import {
   UnstableMiddleware,
   UnstableMiddlewareContext,
-} from '@modern-js/runtime/server';
+} from '@Modern.js/runtime/server';
 
 const time: UnstableMiddleware = async (c: UnstableMiddlewareContext, next) => {
   const start = Date.now();
@@ -133,30 +58,41 @@ const time: UnstableMiddleware = async (c: UnstableMiddlewareContext, next) => {
 export const unstableMiddleware: UnstableMiddleware[] = [time];
 ```
 
-:::note
-For detailed API and more usage, please refer to [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware)
+:::info
+For detailed API and more usage, see [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware).
 :::
 
-## Managed Page Requests with BFF
+### Hooks
 
-The second way is to use BFF to Managed page rendering. In this way, all requests will first hit the BFF service.
+:::warning
+We recommend using UnstableMiddleware instead of Hooks.
+:::
 
-This method can uniformly control the server-level logic of all requests through BFF. Therefore, it is suitable for scenarios where the server-level logic is complex, and BFF and pages need common server-level logic. But it still relies on the Web Server of Modern.js as a whole, and cannot run the logic on existing services.
+Modern.js provides Hooks to control specific logic in the Web Server. All page requests will pass through Hooks.
 
-To use this method, we first need to enable the "BFF" function through `pnpm new`. Then add [`bff.enableHandleWeb`](/configure/app/bff/enable-handle-web.html) configuration in the configuration file:
+Currently, two types of Hooks are available: `AfterMatch` and `AfterRender`. Developers can implement them in `server/index.ts` as follows:
 
 ```ts
-export default defineConfig({
-  bff: {
-    enableHandleWeb: true,
-  },
-});
+import type {
+  AfterMatchHook,
+  AfterRenderHook,
+} from '@modern-js/runtime/server';
+
+export const afterMatch: AfterMatchHook = (ctx, next) => {
+  next();
+};
+
+export const afterRender: AfterRenderHook = (ctx, next) => {
+  next();
+};
 ```
 
-When this value is set to `true`, page request traffic also goes through the BFF, and the logic built into Modern.js for page rendering defaults to running as the last middleware for the BFF service.
+Best practices when using Hooks:
 
-## Fully Customized Web Server
+1. Perform authorization checks in afterMatch.
+2. Handle Rewrite and Redirect in afterMatch.
+3. Inject HTML content in afterRender.
 
-:::note
-Comming soon..
+:::info
+For detailed API and more usage, see [Hook](/apis/app/runtime/web-server/hook).
 :::

package/docs/zh/apis/app/runtime/web-server/hook.mdx

@@ -6,6 +6,10 @@ title: Hook
 
 用于拓展 Modern.js 内置的 Web Server，所有的页面请求都会经过 Hook。
 
+:::warning
+推荐使用 [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware) 来处理页面请求。
+:::
+
 :::note
 更多内容可以查看[自定义 Web Server](/guides/advanced-features/web-server)。
 :::

package/docs/zh/apis/app/runtime/web-server/middleware.mdx

@@ -6,11 +6,9 @@ title: Middleware
 
 用于拓展 Modern.js 内置的 Web Server，与 [Hook](/apis/app/runtime/web-server/hook) 不同的是，Middleware 可以直接操作 Node 原生的请求、响应对象，并且可以使用框架拓展。
 
-:::note
-
-在下一个大版本，Modern.js 将会使用新 Middleware 来替代该写法。
+:::warning
 
-推荐使用 [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware) 处理页面请求。
+Middleware 将会在下一个大版本中废弃，推荐使用 [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware) 处理页面请求。
 
 :::
 
@@ -119,22 +117,3 @@ export const Middleware = () => async (ctx, next) => {
   ctx.response.locals.rpc = createRpcInstance();
 };
 ```
-
-### 框架拓展
-
-Middleware 还可以和 BFF 一样，使用运行时框架拓展。Modern.js 约定，当使用框架运行时拓展时，类型信息从 `@modern-js/runtime/{namespace}` 下导出，Middleware 可以使用框架语法，例如框架中间件写法，以下是伪代码：
-
-```ts
-import { SomeType } from '@modern-js/runtime/{namespace}';
-
-export const middleware: SomeType = (ctx, next) => {
-  console.log(ctx.url);
-  next();
-};
-```
-
-默认情况下，在安装框架拓展插件后，Web Server 的框架拓展能力是关闭的。如果希望使用框架拓展，可以通过 [`server.enableFrameworkExt`](/configure/app/server/enable-framework-ext.html) 开启。
-
-:::info
-框架拓展导出的类型名不一定为 Middleware，命名由框架拓展插件。
-:::

package/docs/zh/configure/app/runtime/0-intro.mdx

@@ -63,6 +63,10 @@ export default defineRuntimeConfig(entryName => {
 使用 `src/modern.runtime.ts` 配置方式需要 Modern.js 版本 **MAJOR_VERSION.66.0** 或更高版本。
 :::
 
+import RuntimeCliConfig from '@site-docs/components/runtime-cli-config';
+
+<RuntimeCliConfig />
+
 ## 配置方式演进
 
 在 MAJOR_VERSION.66.0 之前，运行时配置分散在多个位置：

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

@@ -2,7 +2,7 @@
 title: router
 ---
 
-# runtime.router
+# router
 
 import RouterLegacyTip from "@site-docs/components/router-legacy-tip"
 

package/docs/zh/configure/app/runtime/state.mdx

@@ -2,7 +2,7 @@
 title: state
 ---
 
-# runtime.state
+# state
 
 - **类型：** `boolean | object`
 - **默认值：** `false`

package/docs/zh/guides/advanced-features/web-server.mdx

@@ -4,25 +4,17 @@ sidebar_position: 16
 
 # 自定义 Web Server
 
-Modern.js 作为以客户端为中心的开发框架，对服务端的定制能力较弱。而在有些开发场景下，需要定制特殊的服务端逻辑，例如用户鉴权、请求预处理、添加页面渲染骨架等。
+Modern.js 将大部分项目需要的服务端能力都进行了封装，通常项目无需进行服务端开发。但在有些开发场景下，例如用户鉴权、请求预处理、添加页面渲染骨架等，项目仍需要对服务端进行定制。
 
-一些开发者可能会有疑惑，Modern.js 已经提供了 [BFF 能力](/guides/advanced-features/bff/function.html)，为什么还需要**自定义 Web Server**。
+Modern.js 提供了 **渲染中间件（Middleware）** 与**生命周期钩子（Hook）** 两类 API 来扩展 Web Server。
 
-因为在默认情况下，页面路由并不会经过 BFF，它没有办法为页面访问提供服务端的定制逻辑。之所以这样设计，是因为我们不希望控制页面的服务与 BFF 服务绑定在一起，避免 BFF 的框架限制页面的部署方式。例如将页面与 BFF 分开托管、将页面服务部署到非 Node 的环境上，或是针对部署平台做定制等。
-
-出于上述原因，Modern.js 提供了三种方式，让项目可以在根据需求，渐进式的定制服务端能力。
-
-:::warning
-三种扩展方式无法同时工作，开发者需要根据场景选择合适的方式。
+:::note
+Middleware 与 Hook 只会在用户请求页面路由时生效，BFF 路由不会经过这些 API。
 :::
 
-## 使用 API 扩展 Web Server
-
-第一种方式是通过 Modern.js 提供的服务端运行时 API，在特定的生命周期对服务端进行定制。提供这种方式的目的是在部分情况下，开发者并不需要控制完整的 Web Server，只需要添加服务端逻辑即可。
+## 开启自定义 Web Server
 
-这种方式无法控制完整的 Web Server，并且扩展逻辑**只在请求页面时生效**。因此，它适用于服务端逻辑相对简单，不希望额外创建 BFF 或者 BFF 和页面无需公用服务端逻辑场景。
-
-可以在项目根目录执行 `pnpm run new` 命令，开启「自定义 Web Serve」功能：
+开发者可以在项目根目录执行 `pnpm run new` 命令，开启「自定义 Web Server」功能：
 
 ```bash
 ? 请选择你想要的操作 创建工程元素
@@ -39,78 +31,13 @@ export default defineConfig({
 });
 ```
 
-开启功能后，项目目录下会自动创建 `server/index.ts` 文件，可以在这个文件中编写自定义逻辑。Modern.js 提供了 **Hook** 与 **Middleware** 两类 API 来扩展 Web Server。
-
-### Hook
-
-Modern.js 提供的 Hook 用于控制 Web Server 中的内置逻辑，所有的页面请求都会经过 Hook。
-
-目前提供了两种 Hook，分别是 `AfterMatch` 和 `AfterRender`，可以用于修改渲染结果。可以在 `server/index.ts` 中这样写：
+开启功能后，项目目录下会自动创建 `server/index.ts` 文件，可以在这个文件中编写自定义逻辑。
 
-```ts
-import type {
-  AfterMatchHook,
-  AfterRenderHook,
-} from '@modern-js/runtime/server';
-
-export const afterMatch: AfterMatchHook = (ctx, next) => {
-  next();
-};
-
-export const afterRender: AfterRenderHook = (ctx, next) => {
-  next();
-};
-```
-
-项目在使用 Hook 时，应该有以下最佳实践：
-
-1. 在 afterMatch 中做权限校验。
-2. 在 afterMatch 做 Rewrite 和 Redirect。
-3. 在 afterRender 中做 HTML 内容注入。
-
-:::note
-详细 API 和更多用法可以查看 [Hook](/apis/app/runtime/web-server/hook)。
-:::
-
-### Middleware
-
-对于某些项目，可能在服务端有更多的需求，Modern.js 提供了 Middleware 为 Web Server 添加前置中间件。它只能运行在 Node 环境下，因此如果项目被部署到其他环境中，如 Worker 环境，则不可以使用 Middleware。
-
-:::note
-下一个大版本，Modern.js 将会使用新 Middleware 来替代该写法。
-
-推荐使用 [UnstableMiddleware](/guides/advanced-features/web-server.html#unstablemiddleware) 处理页面请求。
-:::
-
-Modern.js 默认提供了一套 API 供项目使用：
-
-```ts
-import { Middleware } from '@modern-js/runtime/server';
-
-export const middleware: Middleware = (context, next) => {
-  const {
-    source: { req, res },
-  } = context;
-  console.log(req.url);
-  next();
-};
-```
-
-:::note
-详细 API 和更多用法可以查看 [Middleware](/apis/app/runtime/web-server/middleware)。
-:::
-
-项目在使用 Middleware 时，应该有以下最佳实践：
-
-1. 在 Middleware 中可以直接操作原生的请求、响应对象，做数据打点、注入 SSR 渲染可能用到的 Node 服务（数据库、Redis 等）。
-2. 在 Middleware 里可以做类似功能打标、爬虫优化等功能。
-3. 在 Middleware 里可以无视后续默认渲染，自定义渲染流程。
-
-**总的来说，CSR 项目中，使用 Hook 基本能满足简单场景的所有需求。SSR 项目中，可以使用 Middleware 做更复杂的 Node 扩展。**
+## 自定义 Web Server 能力
 
 ### Unstable Middleware
 
-Modern.js 将提供新 Middleware 为 Web Server 添加前置中间件，支持在处理页面的前后执行自定义逻辑。
+Modern.js 支持为 Web Server 添加渲染中间件，支持在处理页面路由的前后执行自定义逻辑。
 
 ```ts title="server/index.ts"
 import {
@@ -131,30 +58,41 @@ const time: UnstableMiddleware = async (c: UnstableMiddlewareContext, next) => {
 export const unstableMiddleware: UnstableMiddleware[] = [time];
 ```
 
-:::note
-详细 API 和更多用法查看 [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware)
+:::info
+详细 API 和更多用法查看 [UnstableMiddleware](/apis/app/runtime/web-server/unstable_middleware)。
 :::
 
-## 通过 BFF 托管页面请求
+### Hook
 
-第二种方式，是利用 BFF 来托管页面渲染，这种方式下，所有的请求都会先打到 BFF 的服务。
+:::warning
+我们推荐使用 UnstableMiddleware 代替 Hook。
+:::
 
-因为这种方式可以通过 BFF 统一控制所有请求的服务端逻辑。因此，它适用于服务端逻辑复杂，BFF 和页面需要公用服务端逻辑的场景。但它整体还是依托于 Modern.js 的 Web Server 运行，无法将逻辑运行在已有的服务上。
+Modern.js 提供的 Hook 用于控制 Web Server 中的特定逻辑，所有的页面请求都会经过 Hook。
 
-使用这种方式，我们需要先通过 `pnpm new` 开启「BFF」功能。然后在配置文件中添加 [`bff.enableHandleWeb`](/configure/app/bff/enable-handle-web.html) 配置：
+目前提供了两种 Hook，分别是 `AfterMatch` 和 `AfterRender`，开发者可以在 `server/index.ts` 中这样写：
 
 ```ts
-export default defineConfig({
-  bff: {
-    enableHandleWeb: true,
-  },
-});
+import type {
+  AfterMatchHook,
+  AfterRenderHook,
+} from '@modern-js/runtime/server';
+
+export const afterMatch: AfterMatchHook = (ctx, next) => {
+  next();
+};
+
+export const afterRender: AfterRenderHook = (ctx, next) => {
+  next();
+};
 ```
 
-当该值设置为 `true` 时，页面请求流量也会经过 BFF，并且 Modern.js 内置的页面渲染的逻辑默认会作为 BFF 服务的最后一个中间件运行。
+项目在使用 Hook 时，应该有以下最佳实践：
 
-## 完全自定义的 Web Server
+1. 在 afterMatch 中做权限校验。
+2. 在 afterMatch 做 Rewrite 和 Redirect。
+3. 在 afterRender 中做 HTML 内容注入。
 
-:::note
-敬请期待
+:::info
+详细 API 和更多用法可以查看 [Hook](/apis/app/runtime/web-server/hook)。
 :::

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.66.1-alpha.0",
+  "version": "2.66.1-alpha.2",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"

package/docs/en/configure/app/server/enable-framework-ext.mdx

@@ -1,49 +0,0 @@
----
-title: enableFrameworkExt
----
-
-# server.enableFrameworkExt
-
-- **Type:** `boolean`
-- **Default:** `false`
-
-By default, when the [custom Web Server feature](/guides/advanced-features/web-server) is enabled, the Middleware will use the Modern.js's syntax.
-
-Enabling `server.enableFrameworkExt` allows the use of syntax extensions from other frameworks.
-
-```ts title="modern.config.ts"
-export default defineConfig({
-  server: {
-    enableFrameworkExt: true,
-  },
-});
-```
-
-## Example
-
-Default usage:
-
-```ts title="server/index.ts"
-import { Middleware } from '@modern-js/runtime/server';
-
-export const middleware: Middleware = (ctx, next) => {
-  console.log(ctx.request.url);
-  next();
-};
-```
-
-After enabling it, the Middleware type will be exported from other namespaces, and syntax extensions from frameworks can be used:
-
-```ts title="server/index.ts"
-import { SomeType } from '@modern-js/runtime/{namespace}';
-
-export const middleware: SomeType = (...args) => {
-  console.log(args[0].url);
-  next();
-};
-```
-
-:::note
-The above code is pseudocode, and the specific usage needs to refer to the corresponding framework extension.
-
-:::

package/docs/zh/configure/app/server/enable-framework-ext.mdx

@@ -1,49 +0,0 @@
----
-title: enableFrameworkExt
----
-
-# server.enableFrameworkExt
-
-- **类型：** `boolean`
-- **默认值：** `false`
-
-默认情况下，开启[自定义 Web Server 功能](/guides/advanced-features/web-server)后，Middleware 会使用 Modern.js 本身的语法。
-
-开启 `server.enableFrameworkExt` 可以使用其他框架扩展的语法。
-
-```ts title="modern.config.ts"
-export default defineConfig({
-  server: {
-    enableFrameworkExt: true,
-  },
-});
-```
-
-## 示例
-
-默认的使用方式：
-
-```ts title="server/index.ts"
-import { Middleware } from '@modern-js/runtime/server';
-
-export const middleware: Middleware = (ctx, next) => {
-  console.log(ctx.request.url);
-  next();
-};
-```
-
-开启后，Middleware 类型将从其他命名空间下导出，并且可以使用框架拓展的语法：
-
-```ts title="server/index.ts"
-import { SomeType } from '@modern-js/runtime/{namespace}';
-
-export const middleware: SomeType = (...args) => {
-  console.log(args[0].url);
-  next();
-};
-```
-
-:::note
-上述代码为伪代码，具体使用方式需要参考对应的框架拓展。
-
-:::