@maiyunnet/kebab 9.18.1 → 9.19.0

package/index.d.ts

@@ -5,7 +5,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export declare const VER = "9.18.1";
+export declare const VER = "9.19.0";
 /** --- 框架根目录，以 / 结尾  --- */
 export declare const ROOT_PATH: string;
 /** --- 框架的 LIB，以 / 结尾 --- */

package/index.js

@@ -6,7 +6,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export const VER = '9.18.1';
+export const VER = '9.19.0';
 // --- 服务端用的路径 ---
 const imu = decodeURIComponent(import.meta.url).replace('file://', '').replace(/^\/(\w:)/, '$1');
 /** --- /xxx/xxx --- */

package/lib/undici/request.d.ts

@@ -47,6 +47,16 @@ export declare class Request {
      * @param timeout 秒
      */
     timeout(timeout: number): this;
+    /**
+     * --- 设置空闲连接允许复用的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒
+     */
+    keepAliveTimeout(timeout: number): this;
+    /**
+     * --- 设置连接建立后允许承接新请求的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制
+     */
+    reuseTimeout(timeout: number): this;
     /**
      * --- 设置网络异常后的重试次数 ---
      * @param retry 重试次数，默认为 1；非幂等请求需由调用方保证安全

package/lib/undici/request.js

@@ -59,6 +59,22 @@ export class Request {
         this._opt['timeout'] = timeout;
         return this;
     }
+    /**
+     * --- 设置空闲连接允许复用的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒
+     */
+    keepAliveTimeout(timeout) {
+        this._opt['keepAliveTimeout'] = timeout;
+        return this;
+    }
+    /**
+     * --- 设置连接建立后允许承接新请求的最长时间 ---
+     * @param timeout 秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制
+     */
+    reuseTimeout(timeout) {
+        this._opt['reuseTimeout'] = timeout;
+        return this;
+    }
     /**
      * --- 设置网络异常后的重试次数 ---
      * @param retry 重试次数，默认为 1；非幂等请求需由调用方保证安全

package/lib/undici.d.ts

@@ -74,6 +74,10 @@ export declare function fetch(input: string | URL | Request, init?: RequestInit
     'hosts'?: Record<string, string> | string;
     /** --- 网络异常后的重试次数，默认 0；流式请求体不可重试，非幂等请求需由调用方保证安全 --- */
     'retry'?: number;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制 --- */
+    'reuseTimeout'?: number;
 }): Promise<Response>;
 /**
  * --- 发起一个请求 ---
@@ -152,6 +156,10 @@ export interface IRequestOptions {
     };
     /** --- 连接是否保持长连接（即是否允许复用），默认为 true --- */
     'keep'?: boolean;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒；自定义 Agent 由其自身配置 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制；自定义 Agent 由其自身配置 --- */
+    'reuseTimeout'?: number;
     /** --- 复用池名/Agent，默认为 default --- */
     'reuse'?: string | undici.ProxyAgent | undici.Agent;
     /** --- cookie 托管对象 --- */
@@ -170,6 +178,10 @@ export interface IMproxyOptions {
     'hosts'?: Record<string, string> | string;
     'local'?: string;
     'headers'?: THttpHeaders;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制 --- */
+    'reuseTimeout'?: number;
     /** --- 过滤 header，返回 true 则留下 --- */
     filter?: (h: string) => boolean;
     /** --- 默认为 default --- */
@@ -184,6 +196,10 @@ export interface IRproxyOptions {
     'hosts'?: Record<string, string> | string;
     'local'?: string;
     'headers'?: THttpHeaders;
+    /** --- 空闲连接允许复用的最长秒数；非正数或无效值按未设置处理；默认无服务端提示时为 4 秒，有提示时采用提示值减 2 秒且最多 600 秒 --- */
+    'keepAliveTimeout'?: number;
+    /** --- 连接建立后允许承接新请求的最长秒数；非正数或无效值按未设置处理；达到后不再复用但不会中断在途请求，默认不限制 --- */
+    'reuseTimeout'?: number;
     /** --- 过滤 header，返回 true 则留下 --- */
     filter?: (h: string) => boolean;
     /** --- 正向 mproxy 代理，url 如 https://xxx/abc --- */

package/lib/undici.js

@@ -45,14 +45,31 @@ function normalizeRetry(retry) {
     return (typeof retry === 'number') && Number.isFinite(retry) ?
         Math.max(0, Math.floor(retry)) : 0;
 }
+/**
+ * --- 将 Agent 的秒数配置转换为毫秒 ---
+ * @param timeout 秒数
+ * @returns 未设置或数值无效时返回 undefined，否则返回毫秒数
+ */
+function normalizeAgentTimeout(timeout) {
+    if (timeout === undefined) {
+        return undefined;
+    }
+    const milliseconds = timeout * 1_000;
+    if (!Number.isFinite(milliseconds) || (milliseconds <= 0)) {
+        return undefined;
+    }
+    return milliseconds;
+}
 /** --- 获取或创建 undici.agent 对象 --- */
 function getAgent(opt = {}) {
     let k = opt.reuse ?? 'default';
     if (typeof k !== 'string') {
         return k;
     }
+    const keepAliveTimeout = normalizeAgentTimeout(opt.keepAliveTimeout);
+    const reuseTimeout = normalizeAgentTimeout(opt.reuseTimeout);
     if (k === 'default') {
-        // --- hosts/local/keep 均会影响 agent 行为，需生成独立的 key ---
+        // --- hosts/local/keep/连接时长均会影响 agent 行为，需生成独立的 key ---
         const features = [];
         if (opt.hosts) {
             features.push(`h:${lCrypto.hashHmac('md5', lText.stringifyJson(opt.hosts))}`);
@@ -63,6 +80,12 @@ function getAgent(opt = {}) {
         if (opt.keep === false) {
             features.push('k:0');
         }
+        if (keepAliveTimeout !== undefined) {
+            features.push(`ka:${keepAliveTimeout}`);
+        }
+        if (reuseTimeout !== undefined) {
+            features.push(`rt:${reuseTimeout}`);
+        }
         if (features.length > 0) {
             k = features.join('|');
         }
@@ -74,6 +97,13 @@ function getAgent(opt = {}) {
                 lookup: buildDnsLookup(opt.hosts),
             },
             'pipelining': opt.keep === false ? 0 : 1,
+            ...(keepAliveTimeout === undefined ? {} : {
+                'keepAliveTimeout': keepAliveTimeout,
+                'keepAliveMaxTimeout': keepAliveTimeout,
+            }),
+            ...(reuseTimeout === undefined ? {} : {
+                'clientTtl': reuseTimeout,
+            }),
         }));
     }
     return agents.get(k);
@@ -293,6 +323,8 @@ export async function fetch(input, init = {}) {
         'hosts': init.hosts,
         'mproxy': init.mproxy,
         'retry': init.retry,
+        'keepAliveTimeout': init.keepAliveTimeout,
+        'reuseTimeout': init.reuseTimeout,
         'signal': init.signal ?? undefined,
         'follow': init.redirect === 'follow' ? 10 : 0,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.18.1",
+  "version": "9.19.0",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [

package/sys/child.js

@@ -203,7 +203,7 @@ async function requestHandler(req, res, https) {
         'timer': {},
         'timeout': 30_000,
         'callback': () => {
-            if (!req.socket?.writable) {
+            if (!sCtr.isHttpRequestAvailable(req, res)) {
                 // --- 用户连接已中断 ---
                 return;
             }

package/sys/ctr.d.ts

@@ -58,6 +58,13 @@ export type TValibotResult<TSchema extends v.GenericSchema, TIssue extends v.Bas
     readonly issues: [TIssue, ...TIssue[]];
     readonly response: kebab.Json[];
 };
+/**
+ * --- 判断当前 HTTP 请求是否仍可响应 ---
+ * @param req 请求对象
+ * @param res 响应对象
+ * @returns 客户端对应的请求流仍可响应时返回 true
+ */
+export declare function isHttpRequestAvailable(req: http2.Http2ServerRequest | http.IncomingMessage, res: http2.Http2ServerResponse | http.ServerResponse): boolean;
 export declare class Ctr {
     /** --- 路由参数序列数组 --- */
     protected _param: string[];
@@ -206,17 +213,15 @@ export declare class Ctr {
     /**
      * --- 加载 React 全页面进行 SSR 渲染，组件需渲染完整 HTML 文档（含 html/head/body），无需 EJS ---
      * --- 框架自动注入 props：_urlBase/_urlFull/_urlStc/_staticVer/_staticPath/_staticPathFull ---
-     * --- 多语言：自动注入 _locale（当前语言名）和 _localeData（已载语言包的合并键值对） ---
+     * --- 多语言：自动注入 _locale（当前语言名）和 _localeData（当前语种已载语言包的合并键值对） ---
      * --- 组件内创建：const l = (key: string, ...args: string[]): string => { let i = 0; return (_localeData[key] ?? key).replace(/\?/g, () => args[i++] ?? ''); }; ---
      * @param path 页面组件路径（相对于 stc/ 目录，不含扩展名，tsx 编译后的 .js）
      * @param props 传入组件的 props，框架常量自动合并，整体序列化为内联 JSON 供客户端水合复用
      * @param opt 可选配置
      */
     protected _loadReactPage(path: string, props?: Record<string, kebab.Json>, opt?: {
-        /** --- 是否注入客户端水合脚本（import map + hydrateRoot），默认 true --- */
+        /** --- 是否注入客户端水合 bundle，默认 true；设为 false 时仅输出服务端渲染的 HTML --- */
         'hydrate'?: boolean;
-        /** --- react/react-dom/react-router-dom 版本号，用于 esm.sh CDN，默认 19 --- */
-        'reactVer'?: string;
         /**
          * --- 路由模式，不传则不注入任何 Router，组件自行管理路由（如 MemoryRouter）或无路由 ---
          * --- 'browser'：服务端用 StaticRouter，客户端用 BrowserRouter，地址栏与路由联动 ---
@@ -234,14 +239,6 @@ export declare class Ctr {
          */
         'staticPath'?: string;
     }): Promise<string>;
-    /**
-     * --- 递归扫描 JS 文件中的 import 语句，收集第三方 bare specifier ---
-     * @param filePath 当前要扫描的文件绝对路径
-     * @param scannedFiles 已扫描文件集（去重用）
-     * @param extraImports 收集到的第三方包名集合
-     * @param builtinImports 内置 import map，已有条目不重复添加
-     */
-    private _scanImports;
     /**
      * --- 设置校验错误返回值 ---
      * @param rtn 返回值数组

package/sys/ctr.js

@@ -19,6 +19,27 @@ export function clearLocaleData() {
     localeFiles = [];
     localeData = {};
 }
+/**
+ * --- 判断当前 HTTP 请求是否仍可响应 ---
+ * @param req 请求对象
+ * @param res 响应对象
+ * @returns 客户端对应的请求流仍可响应时返回 true
+ */
+export function isHttpRequestAvailable(req, res) {
+    if (req.destroyed && !req.complete) {
+        return false;
+    }
+    if (('stream' in req) && (req.stream.closed || req.stream.destroyed)) {
+        return false;
+    }
+    if (req.socket.destroyed || !req.socket.writable) {
+        return false;
+    }
+    if (res.destroyed || res.closed || res.writableEnded || !res.writable) {
+        return false;
+    }
+    return true;
+}
 export class Ctr {
     /** --- 路由参数序列数组 --- */
     _param = [];
@@ -69,7 +90,13 @@ export class Ctr {
     }
     /** --- 当前用户连接是否还在连接中 --- */
     get _isAvail() {
-        return this._req.socket.writable;
+        if (this._socket) {
+            return this._socket.writable;
+        }
+        if (!this._res) {
+            return !this._req.socket.destroyed && this._req.socket.writable;
+        }
+        return isHttpRequestAvailable(this._req, this._res);
     }
     /** --- timeout 的 timer --- */
     _timer;
@@ -237,7 +264,7 @@ export class Ctr {
     /**
      * --- 加载 React 全页面进行 SSR 渲染，组件需渲染完整 HTML 文档（含 html/head/body），无需 EJS ---
      * --- 框架自动注入 props：_urlBase/_urlFull/_urlStc/_staticVer/_staticPath/_staticPathFull ---
-     * --- 多语言：自动注入 _locale（当前语言名）和 _localeData（已载语言包的合并键值对） ---
+     * --- 多语言：自动注入 _locale（当前语言名）和 _localeData（当前语种已载语言包的合并键值对） ---
      * --- 组件内创建：const l = (key: string, ...args: string[]): string => { let i = 0; return (_localeData[key] ?? key).replace(/\?/g, () => args[i++] ?? ''); }; ---
      * @param path 页面组件路径（相对于 stc/ 目录，不含扩展名，tsx 编译后的 .js）
      * @param props 传入组件的 props，框架常量自动合并，整体序列化为内联 JSON 供客户端水合复用
@@ -245,13 +272,23 @@ export class Ctr {
      */
     async _loadReactPage(path, props = {}, opt = {}) {
         // --- 约定：传入路径不含 .page 后缀，框架自动补全（对应 build 命令的 *.page.tsx 约定）---
-        // --- 组件 JS 从 stc 目录读取，浏览器同样通过 staticPath（支持 CDN）下载 ---
+        // --- 服务端读取 tsc 生成的组件 JS，浏览器读取 kebab build 生成的 bundle ---
         const componentPath = this._config.const.rootPath + 'stc/' + path + '.page.js';
         if (!await lFs.isFile(componentPath)) {
             lCore.debug(`[CTR][_loadReactPage] componentPath ${componentPath} is not a file`);
             lCore.log(this, `[CTR][_loadReactPage] componentPath ${componentPath} is not a file`, '-error');
             return '';
         }
+        const bundlePath = this._config.const.rootPath + 'stc/' + path + '.page.bundle.js';
+        if ((opt.hydrate !== false) && !await lFs.isFile(bundlePath)) {
+            /** --- 完整错误仅写入服务端日志，避免向客户端暴露文件系统路径 --- */
+            const message = `[CTR][_loadReactPage] bundlePath ${bundlePath} is not a file; ` +
+                `run "npx kebab build -d ${this._config.const.rootPath}stc"`;
+            lCore.debug(message);
+            lCore.log(this, message, '-error');
+            this._httpCode = 500;
+            return '<h1>500 Server Error</h1><hr>Kebab';
+        }
         try {
             const reactDomServer = await import('react-dom/server');
             const importPath = componentPath.startsWith('/')
@@ -260,11 +297,8 @@ export class Ctr {
             const mod = await import(importPath);
             const component = mod.default;
             const react = await import('react');
-            // --- 语言包数据：合并所有已加载包的键值，供组件使用 _localeData 实现多语言 ---
-            const localeData = {};
-            for (const pkg in this._localeData) {
-                Object.assign(localeData, this._localeData[pkg]);
-            }
+            // --- 语言包数据：当前语种的各命名包已由 _loadLocale 合并 ---
+            const localeData = { ...(this._localeData[this._locale] ?? {}) };
             // --- 把框架常量合并进 props，与 _loadView 行为一致 ---
             const staticPath = opt.staticPath ?? this._config.set.staticPath;
             const fullProps = {
@@ -278,67 +312,22 @@ export class Ctr {
                 '_locale': this._locale,
                 '_localeData': localeData,
             };
+            if (opt.router === 'browser') {
+                // --- BrowserRouter 的 basename 同时用于服务端 StaticRouter 和客户端水合 ---
+                const base = opt.routerBase ?? '';
+                const routerBase = this._config.const.urlBase + base.replace(/^\//, '');
+                fullProps['_routerBase'] = routerBase.replace(/\/$/, '');
+            }
             // --- 框架自动注入的 HTML 片段，用户组件无需手动渲染 ---
-            let headInject = '';
             let bodyInject = '';
             if (opt.hydrate !== false) {
-                const reactVer = opt.reactVer ?? '19';
-                const esm = 'https://esm.sh/';
-                // --- 检查是否有 npx kebab build 生成的自包含预构建包 ---
-                const bundlePath = this._config.const.rootPath + 'stc/' + path + '.page.bundle.js';
-                const hasBundle = await lFs.isFile(bundlePath);
-                if (opt.router === 'browser') {
-                    // --- BrowserRouter 模式：_routerBase 注入 props，供水合脚本读取 ---
-                    const base = opt.routerBase ?? '';
-                    const routerBase = this._config.const.urlBase + base.replace(/^\//, '');
-                    fullProps['_routerBase'] = routerBase.replace(/\/$/, '');
-                }
                 // --- propsJson 在渲染前序列化，框架直接注入 HTML，组件无需手动渲染 ---
                 const propsJson = lText.stringifyJson(fullProps).replace(/<\/script>/gi, '<\\/script>');
-                let hydrateScript;
-                if (hasBundle) {
-                    // --- bundle 模式：bundle 自包含 React + 水合逻辑，无需 import map ---
-                    const clientUrl = `${staticPath}${path}.page.bundle.js?v=${this._config.set.staticVer}`;
-                    hydrateScript = `import'${clientUrl}';`;
-                }
-                else {
-                    // --- 开发模式（tsc 编译 .js）：通过 esm.sh import map 解析 bare import ---
-                    const clientUrl = `${staticPath}${path}.page.js?v=${this._config.set.staticVer}`;
-                    // --- 内置 import map 条目（React 生态核心包）---
-                    const builtinImports = {
-                        'react': `${esm}react@${reactVer}`,
-                        'react-dom': `${esm}react-dom@${reactVer}`,
-                        'react-dom/client': `${esm}react-dom@${reactVer}/client`,
-                        'react/jsx-runtime': `${esm}react@${reactVer}/jsx-runtime`,
-                        'react-router-dom': `${esm}react-router-dom@7?external=react,react-dom`,
-                    };
-                    // --- 自动扫描入口 JS 及其相对引用，收集所有第三方 bare specifier ---
-                    const scannedFiles = new Set();
-                    const extraImports = new Set();
-                    await this._scanImports(componentPath, scannedFiles, extraImports, builtinImports);
-                    // --- 第三方包统一通过 esm.sh 解析，external react/react-dom 避免重复加载 ---
-                    for (const pkg of extraImports) {
-                        builtinImports[pkg] = `${esm}${pkg}?external=react,react-dom`;
-                    }
-                    // --- import map 注入到 </head> 前 ---
-                    headInject = `<script type="importmap">${lText.stringifyJson({ 'imports': builtinImports })}</script>`;
-                    // --- BrowserRouter 模式多一段 Router 导入与包裹层 ---
-                    const routerImport = opt.router === 'browser' ? `import{BrowserRouter}from'react-router-dom';` : '';
-                    const routerCreate = opt.router === 'browser'
-                        ? `createElement(BrowserRouter,{basename:p._routerBase},createElement(App,p))`
-                        : `createElement(App,p)`;
-                    hydrateScript =
-                        `import{hydrateRoot}from'react-dom/client';` +
-                            `import{createElement}from'react';` +
-                            routerImport +
-                            `import App from'${clientUrl}';` +
-                            `const p=JSON.parse(document.getElementById('__kebab_props__').textContent);` +
-                            `hydrateRoot(document,${routerCreate});`;
-                }
+                const clientUrl = `${staticPath}${path}.page.bundle.js?v=${this._config.set.staticVer}`;
                 // --- props JSON + 水合脚本注入到 </body> 前 ---
                 bodyInject =
                     `<script id="__kebab_props__" type="application/json">${propsJson}</script>` +
-                        `<script type="module">${hydrateScript}</script>`;
+                        `<script type="module">import'${clientUrl}';</script>`;
             }
             // --- BrowserRouter 模式：服务端用 StaticRouter 渲染，与客户端的 BrowserRouter 等价 ---
             // --- component 来自动态 import，TypeScript 无法精确推断，需要明确限定 element 类型 ---
@@ -352,10 +341,9 @@ export class Ctr {
                     'basename': fullProps['_routerBase'],
                 }, react.createElement(component, fullProps));
             }
-            // --- 框架将 import map 注入 </head> 前，props JSON + 水合脚本注入 </body> 前 ---
+            // --- 框架将 props JSON + 水合 bundle 注入到 </body> 前 ---
             let html = '<!DOCTYPE html>' + reactDomServer.renderToString(element);
             if (opt.hydrate !== false) {
-                html = html.replace('</head>', headInject + '</head>');
                 html = html.replace('</body>', bodyInject + '</body>');
             }
             return html;
@@ -366,38 +354,6 @@ export class Ctr {
             return '';
         }
     }
-    /**
-     * --- 递归扫描 JS 文件中的 import 语句，收集第三方 bare specifier ---
-     * @param filePath 当前要扫描的文件绝对路径
-     * @param scannedFiles 已扫描文件集（去重用）
-     * @param extraImports 收集到的第三方包名集合
-     * @param builtinImports 内置 import map，已有条目不重复添加
-     */
-    async _scanImports(filePath, scannedFiles, extraImports, builtinImports) {
-        if (scannedFiles.has(filePath)) {
-            return;
-        }
-        scannedFiles.add(filePath);
-        const src = await lFs.getContent(filePath, 'utf8');
-        if (!src) {
-            return;
-        }
-        const re = /\bfrom\s*['"]([^'"]+)['"]/g;
-        let m;
-        while ((m = re.exec(src)) !== null) {
-            const spec = m[1];
-            if (spec.startsWith('./') || spec.startsWith('../')) {
-                // --- 相对引用：解析为绝对路径后递归扫描 ---
-                const dir = filePath.substring(0, filePath.lastIndexOf('/') + 1);
-                const resolved = new URL(spec, 'file://' + dir).pathname;
-                await this._scanImports(resolved, scannedFiles, extraImports, builtinImports);
-            }
-            else if (!spec.startsWith('/') && !spec.startsWith('http') && !(spec in builtinImports)) {
-                // --- 第三方 bare specifier：加入 import map ---
-                extraImports.add(spec);
-            }
-        }
-    }
     /**
      * --- 设置校验错误返回值 ---
      * @param rtn 返回值数组

package/sys/route.d.ts

@@ -51,12 +51,13 @@ export declare function waitCtr(cctr: sCtr.Ctr): Promise<void>;
 /**
  * --- 获取 post 对象（通常已自动获取），如果是文件上传（formdata）的情况则不获取 ---
  * @param req 请求对象
+ * @returns 解析后的 POST 数据，请求传输中断时返回 false
  */
 export declare function getPost(req: http2.Http2ServerRequest | http.IncomingMessage): Promise<{
     'input': string;
     'raw': Record<string, any>;
     'post': Record<string, any>;
-}>;
+} | false>;
 /**
  * --- 获取 formdata 的 post ---
  * @param req 请求头

package/sys/route.js

@@ -453,6 +453,9 @@ export async function run(data) {
     }
     if (reqStartRtn === 1) {
         const rawPost = await getPost(data.req);
+        if (!rawPost) {
+            return true;
+        }
         // --- 原始 POST ---
         middle.setPrototype('_rawPost', rawPost.raw);
         // --- 原始 input ---
@@ -844,6 +847,7 @@ export async function waitCtr(cctr) {
 /**
  * --- 获取 post 对象（通常已自动获取），如果是文件上传（formdata）的情况则不获取 ---
  * @param req 请求对象
+ * @returns 解析后的 POST 数据，请求传输中断时返回 false
  */
 export function getPost(req) {
     return new Promise(function (resolve) {
@@ -861,7 +865,28 @@ export function getPost(req) {
         const maxPostSize = 50 * 1024 * 1024;
         let buffer = Buffer.from('');
         let overflow = false;
-        req.on('data', function (chunk) {
+        let finished = false;
+        let onData;
+        let onEnd;
+        let onError;
+        let onAborted;
+        let onClose;
+        const cleanup = () => {
+            req.off('data', onData);
+            req.off('end', onEnd);
+            req.off('error', onError);
+            req.off('aborted', onAborted);
+            req.off('close', onClose);
+        };
+        const finish = (result) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            cleanup();
+            resolve(result);
+        };
+        onData = (chunk) => {
             if (overflow) {
                 return;
             }
@@ -871,10 +896,10 @@ export function getPost(req) {
                 return;
             }
             buffer = Buffer.concat([buffer, chunk], buffer.length + chunk.length);
-        });
-        req.on('end', function () {
+        };
+        onEnd = () => {
             if (overflow) {
-                resolve({
+                finish({
                     'input': '',
                     'raw': {},
                     'post': {},
@@ -883,7 +908,7 @@ export function getPost(req) {
             }
             const s = buffer.toString();
             if (!s) {
-                resolve({
+                finish({
                     'input': '',
                     'raw': {},
                     'post': {},
@@ -894,14 +919,14 @@ export function getPost(req) {
             if (ct.includes('json')) {
                 try {
                     const raw = lText.parseJson(s);
-                    resolve({
+                    finish({
                         'input': s,
                         'raw': raw,
                         'post': lText.trimJson(raw),
                     });
                 }
                 catch {
-                    resolve({
+                    finish({
                         'input': '',
                         'raw': {},
                         'post': {},
@@ -910,12 +935,26 @@ export function getPost(req) {
                 return;
             }
             const raw = lText.queryParse(s);
-            resolve({
+            finish({
                 'input': s,
                 'raw': raw,
                 'post': lText.trimJson(raw),
             });
-        });
+        };
+        onError = () => {
+            finish(false);
+        };
+        onAborted = () => {
+            finish(false);
+        };
+        onClose = () => {
+            finish(false);
+        };
+        req.on('data', onData);
+        req.on('end', onEnd);
+        req.on('error', onError);
+        req.on('aborted', onAborted);
+        req.on('close', onClose);
     });
 }
 /**

package/www/example/ctr/test.js

@@ -2021,8 +2021,8 @@ error: ${JSON.stringify(res.error)}
     }
     async undiciPost() {
         const echo = [];
-        const res = await lUndici.post(this._internalUrl + 'test/netPost1', { 'a': '1', 'b': '2', 'c': ['1', '2', '3'] });
-        echo.push(`<pre>lUndici.post('${this._internalUrl}test/netPost1', { 'a': '1', 'b': '2', 'c': ['1', '2', '3'] });</pre>
+        const res = await lUndici.post(this._internalUrl + 'test/undiciPost1', { 'a': '1', 'b': '2', 'c': ['1', '2', '3'] });
+        echo.push(`<pre>lUndici.post('${this._internalUrl}test/undiciPost1', { 'a': '1', 'b': '2', 'c': ['1', '2', '3'] });</pre>
 headers: <pre>${JSON.stringify(res.headers, null, 4)}</pre>
 content: <pre>${(await res.getContent())?.toString() ?? 'null'}</pre>
 error: ${JSON.stringify(res.error)}`);
@@ -2033,8 +2033,8 @@ error: ${JSON.stringify(res.error)}`);
     }
     async undiciPostString() {
         const echo = [];
-        const res = await lUndici.post(this._internalUrl + 'test/netPostString1', 'HeiHei');
-        echo.push(`<pre>lUndici.post('${this._internalUrl}test/netPostString1', 'HeiHei');</pre>
+        const res = await lUndici.post(this._internalUrl + 'test/undiciPostString1', 'HeiHei');
+        echo.push(`<pre>lUndici.post('${this._internalUrl}test/undiciPostString1', 'HeiHei');</pre>
 headers: <pre>${JSON.stringify(res.headers, null, 4)}</pre>
 content: <pre>${(await res.getContent())?.toString() ?? 'null'}</pre>
 error: ${JSON.stringify(res.error)}`);
@@ -2045,8 +2045,8 @@ error: ${JSON.stringify(res.error)}`);
     }
     async undiciOpen() {
         const echo = [];
-        const res = await lUndici.open(this._internalUrl + 'test/netPost1').post().data({ 'a': '2', 'b': '0', 'c': ['0', '1', '3'] }).request();
-        echo.push(`<pre>lUndici.open('${this._internalUrl}test/netPost1').post().data({ 'a': '2', 'b': '0', 'c': ['0', '1', '3'] }).request();</pre>
+        const res = await lUndici.open(this._internalUrl + 'test/undiciPost1').post().data({ 'a': '2', 'b': '0', 'c': ['0', '1', '3'] }).request();
+        echo.push(`<pre>lUndici.open('${this._internalUrl}test/undiciPost1').post().data({ 'a': '2', 'b': '0', 'c': ['0', '1', '3'] }).request();</pre>
 headers: <pre>${JSON.stringify(res.headers, null, 4)}</pre>
 content: <pre>${(await res.getContent())?.toString() ?? 'null'}</pre>
 error: ${JSON.stringify(res.error)}`);

package/www/example/stc/view/hello.page.d.ts

@@ -5,7 +5,8 @@
  * 1. 这个 .page.tsx 文件（组件 + IProps）
  * 2. 一个 <link> 标签引入 CSS（如果不需要样式可省略）
  * 3. 在 Ctr 方法里调用 _loadReactPage('view/hello', props)
- * 其他一切由框架自动处理：SSR 渲染、import map、props 注入、客户端水合。
+ * 4. 执行 node ./source/main build -d source/www/example/stc 生成客户端水合 bundle
+ * 其他一切由框架自动处理：SSR 渲染、props 注入、客户端水合。
  */
 import { type ReactElement } from 'react';
 interface IProps {

package/www/example/stc/view/hello.page.js

@@ -6,7 +6,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * 1. 这个 .page.tsx 文件（组件 + IProps）
  * 2. 一个 <link> 标签引入 CSS（如果不需要样式可省略）
  * 3. 在 Ctr 方法里调用 _loadReactPage('view/hello', props)
- * 其他一切由框架自动处理：SSR 渲染、import map、props 注入、客户端水合。
+ * 4. 执行 node ./source/main build -d source/www/example/stc 生成客户端水合 bundle
+ * 其他一切由框架自动处理：SSR 渲染、props 注入、客户端水合。
  */
 import { useState } from 'react';
 export default function HelloPage({ _urlStc, _staticVer, greeting }) {