@lsby/net-core 0.3.26 → 0.3.28

package/dist/cjs/interface/extend/json-base.cjs

@@ -97,12 +97,12 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
     return arr.reduce((s, a) => s.\u6DF7\u5408\u7EC4\u5408(a));
   }
   /**
-   * 同时运行多个模型, 并提供一个函数处理它们的结果
-   * 如果其中任何一个模型发生错误, 则最终模型输出第一个错误
-   * 处理函数的类型是: 所有模型的结果合并 => 泛型A
-   * 新模型的类型是:
-   * - 参数: 所有模型的参数合并
-   * - 错误: 所有模型的错误合并
+   * 同时运行多个行为, 并提供一个函数处理它们的结果
+   * 如果其中任何一个行为发生错误, 则最终行为输出第一个错误
+   * 处理函数的类型是: 所有行为的结果合并 => 泛型A
+   * 新行为的类型是:
+   * - 参数: 所有行为的参数合并
+   * - 错误: 所有行为的错误合并
    * - 返回值: 泛型A
    */
   static \u5E76\u884C\u7EC4\u5408(arr, f) {
@@ -131,10 +131,10 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
   }
   // ================================= 组合 =================================
   /**
-   * 将两个模型串接, 得到一个新模型, 新模型的类型是:
-   * - 参数: a模型的参数
-   * - 错误: a模型的错误+b模型的错误
-   * - 返回值: b模型的返回值
+   * 将两个行为串接, 得到一个新行为, 新行为的类型是:
+   * - 参数: a行为的参数
+   * - 错误: a行为的错误+b行为的错误
+   * - 返回值: b行为的返回值
    */
   \u6D41\u5F0F\u7EC4\u5408(b) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
@@ -145,12 +145,12 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
     });
   }
   /**
-   * 将两个模型串接, 得到一个新的模型
+   * 将两个行为串接, 得到一个新的行为
    * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
-   * 新模型的类型是:
-   * - 参数: a模型的参数+(b模型的参数-a模型的返回值)
-   * - 错误: a模型的错误+b模型的错误
-   * - 返回值: a模型的返回值+b模型的返回值
+   * 新行为的类型是:
+   * - 参数: a行为的参数+(b行为的参数-a行为的返回值)
+   * - 错误: a行为的错误+b行为的错误
+   * - 返回值: a行为的返回值+b行为的返回值
    */
   \u6DF7\u5408\u7EC4\u5408(b) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
@@ -178,6 +178,13 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
       return import_ts_fp_data.Either.pure(\u6211\u7684\u7ED3\u679C.assertRight().getRight());
     });
   }
+  /**
+   * 产生一个代数效应, 在效应中执行当前业务行为, 然后将其正确结果映射为新业务行为
+   * 新行为的类型是:
+   * - 参数: 必须是已有行为的参数的扩展, 因为调用时必须先调用已有行为
+   * - 错误: 已有行为的错误+自定义错误, 因为调用已有行为时可能出错
+   * - 返回值: 自定义数据
+   */
   \u7ED1\u5B9A(f) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
       const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570);

package/dist/cjs/interface/extend/json-wrap.cjs

@@ -99,12 +99,12 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
     return arr.reduce((s, a) => s.\u6DF7\u5408\u7EC4\u5408(a));
   }
   /**
-   * 同时运行多个模型, 并提供一个函数处理它们的结果
-   * 如果其中任何一个模型发生错误, 则最终模型输出第一个错误
-   * 处理函数的类型是: 所有模型的结果合并 => 泛型A
-   * 新模型的类型是:
-   * - 参数: 所有模型的参数合并
-   * - 错误: 所有模型的错误合并
+   * 同时运行多个行为, 并提供一个函数处理它们的结果
+   * 如果其中任何一个行为发生错误, 则最终行为输出第一个错误
+   * 处理函数的类型是: 所有行为的结果合并 => 泛型A
+   * 新行为的类型是:
+   * - 参数: 所有行为的参数合并
+   * - 错误: 所有行为的错误合并
    * - 返回值: 泛型A
    */
   static \u5E76\u884C\u7EC4\u5408(arr, f) {
@@ -133,10 +133,10 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
   }
   // ================================= 组合 =================================
   /**
-   * 将两个模型串接, 得到一个新模型, 新模型的类型是:
-   * - 参数: a模型的参数
-   * - 错误: a模型的错误+b模型的错误
-   * - 返回值: b模型的返回值
+   * 将两个行为串接, 得到一个新行为, 新行为的类型是:
+   * - 参数: a行为的参数
+   * - 错误: a行为的错误+b行为的错误
+   * - 返回值: b行为的返回值
    */
   \u6D41\u5F0F\u7EC4\u5408(b) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
@@ -147,12 +147,12 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
     });
   }
   /**
-   * 将两个模型串接, 得到一个新的模型
+   * 将两个行为串接, 得到一个新的行为
    * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
-   * 新模型的类型是:
-   * - 参数: a模型的参数+(b模型的参数-a模型的返回值)
-   * - 错误: a模型的错误+b模型的错误
-   * - 返回值: a模型的返回值+b模型的返回值
+   * 新行为的类型是:
+   * - 参数: a行为的参数+(b行为的参数-a行为的返回值)
+   * - 错误: a行为的错误+b行为的错误
+   * - 返回值: a行为的返回值+b行为的返回值
    */
   \u6DF7\u5408\u7EC4\u5408(b) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
@@ -180,6 +180,13 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
       return import_ts_fp_data.Either.pure(\u6211\u7684\u7ED3\u679C.assertRight().getRight());
     });
   }
+  /**
+   * 产生一个代数效应, 在效应中执行当前业务行为, 然后将其正确结果映射为新业务行为
+   * 新行为的类型是:
+   * - 参数: 必须是已有行为的参数的扩展, 因为调用时必须先调用已有行为
+   * - 错误: 已有行为的错误+自定义错误, 因为调用已有行为时可能出错
+   * - 返回值: 自定义数据
+   */
   \u7ED1\u5B9A(f) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
       const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570);
@@ -225,17 +232,27 @@ var \u63A5\u53E3\u7C7B\u578B = class {
 
 // src/interface/extend/json-wrap.ts
 var JSON\u72B6\u6001\u63A5\u53E3\u7C7B\u578B = class extends \u63A5\u53E3\u7C7B\u578B {
-  constructor(path, method, \u63D2\u4EF6\u4EEC, \u6B63\u786E\u8FD4\u56DE\u7C7B\u578B, \u9519\u8BEF\u8FD4\u56DE\u7C7B\u578B) {
+  constructor(path, method, \u63D2\u4EF6\u4EEC, \u6B63\u786E\u7ED3\u679C\u7C7B\u578B, \u9519\u8BEF\u7ED3\u679C\u7C7B\u578B) {
     super(
       path,
       method,
       \u63D2\u4EF6\u4EEC,
-      import_zod.z.object({ status: import_zod.z.literal("success"), data: \u6B63\u786E\u8FD4\u56DE\u7C7B\u578B }),
-      import_zod.z.object({ status: import_zod.z.literal("fail"), data: \u9519\u8BEF\u8FD4\u56DE\u7C7B\u578B })
+      import_zod.z.object({ status: import_zod.z.literal("success"), data: \u6B63\u786E\u7ED3\u679C\u7C7B\u578B }),
+      import_zod.z.object({ status: import_zod.z.literal("fail"), data: \u9519\u8BEF\u7ED3\u679C\u7C7B\u578B })
     );
   }
 };
 var JSON\u72B6\u6001\u63A5\u53E3 = class extends \u63A5\u53E3 {
+  \u83B7\u5F97\u63A5\u53E3\u7C7B\u578B() {
+    var c = this.\u83B7\u5F97JSON\u63A5\u53E3\u7C7B\u578B();
+    return new \u63A5\u53E3\u7C7B\u578B(
+      c.\u83B7\u5F97\u8DEF\u5F84(),
+      c.\u83B7\u5F97\u65B9\u6CD5(),
+      c.\u83B7\u5F97\u63D2\u4EF6\u4EEC(),
+      c.\u83B7\u5F97\u6B63\u786E\u7ED3\u679C\u7C7B\u578B().shape.data,
+      c.\u83B7\u5F97\u9519\u8BEF\u7ED3\u679C\u7C7B\u578B().shape.data
+    );
+  }
   async \u8F6C\u6362\u4E1A\u52A1\u7ED3\u679C\u5230\u63A5\u53E3\u7ED3\u679C(\u4E1A\u52A1\u7ED3\u679C) {
     var c = await \u4E1A\u52A1\u7ED3\u679C;
     if (c.isLeft())

package/dist/cjs/interface/extend/json-wrap.d.cts

@@ -1,26 +1,28 @@
 import { z } from 'zod';
-import { Either } from '@lsby/ts-fp-data';
 import { 插件项类型 as _____ } from '../../plugin/plug.cjs';
 import { 正确结果 as ____$1, 错误结果 as ____$2 } from '../../result/result.cjs';
-import { 接口 as __, 计算接口参数 as ______, 计算接口返回 as ______$1 } from '../interface-inst.cjs';
-import { 接口类型 as ____, 接口类型错误结果 as ________, 接口类型正确结果 as ________$1 } from '../interface-type.cjs';
+import { 计算接口返回 as ______, 接口 as __ } from '../interface-inst.cjs';
+import { 接口类型 as ____, 接口类型正确结果 as ________, 接口类型错误结果 as ________$1 } from '../interface-type.cjs';
 import 'express';
+import '@lsby/ts-fp-data';
 import '../../action/action.cjs';
 
-declare class JSON状态接口类型<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确返回类型 extends z.ZodTypeAny, 错误返回类型 extends z.ZodTypeAny> extends ____<路径, 方法, 插件们, z.ZodObject<{
+declare class JSON状态接口类型<路径 extends string | null, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确结果类型 extends z.ZodTypeAny, 错误结果类型 extends z.ZodTypeAny> extends ____<路径, 方法, 插件们, z.ZodObject<{
     status: z.ZodLiteral<'success'>;
-    data: 正确返回类型;
+    data: 正确结果类型;
 }>, z.ZodObject<{
     status: z.ZodLiteral<'fail'>;
-    data: 错误返回类型;
+    data: 错误结果类型;
 }>> {
-    constructor(path: 路径, method: 方法, 插件们: [...插件们], 正确返回类型: 正确返回类型, 错误返回类型: 错误返回类型);
+    constructor(path: 路径, method: 方法, 插件们: [...插件们], 正确结果类型: 正确结果类型, 错误结果类型: 错误结果类型);
 }
 type 任意的JSON状态接口类型 = JSON状态接口类型<any, any, any, any, any>;
-type 计算JSON状态接口返回<接口类型描述> = Promise<Either<z.infer<________<接口类型描述>>['data'], z.infer<________$1<接口类型描述>>['data']>>;
-declare abstract class JSON状态接口<接口类型描述 extends 任意的JSON状态接口类型> extends __<接口类型描述> {
-    protected abstract 业务行为实现(参数: ______<接口类型描述>): 计算JSON状态接口返回<接口类型描述>;
-    转换业务结果到接口结果(业务结果: ______$1<接口类型描述>): Promise<____$1<z.TypeOf<________$1<接口类型描述>>> | ____$2<z.TypeOf<________<接口类型描述>>>>;
+type 转换状态接口描述<A> = A extends JSON状态接口类型<infer 路径, infer 方法, infer 插件们, infer 正确结果类型, infer 错误结果类型> ? ____<路径, 方法, 插件们, 正确结果类型, 错误结果类型> : never;
+type 计算JSON状态接口返回<接口类型描述> = ______<转换状态接口描述<接口类型描述>>;
+declare abstract class JSON状态接口<接口类型描述 extends 任意的JSON状态接口类型> extends __<转换状态接口描述<接口类型描述>> {
+    abstract 获得JSON接口类型(): 接口类型描述;
+    获得接口类型(): 转换状态接口描述<接口类型描述>;
+    转换业务结果到接口结果(业务结果: ______<接口类型描述>): Promise<____$1<z.TypeOf<________<接口类型描述>>> | ____$2<z.TypeOf<________$1<接口类型描述>>>>;
 }
 
-export { JSON状态接口, JSON状态接口类型, type 计算JSON状态接口返回 };
+export { JSON状态接口, JSON状态接口类型, type 计算JSON状态接口返回, type 转换状态接口描述 };

package/dist/cjs/interface/interface-inst.cjs

@@ -54,12 +54,12 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
     return arr.reduce((s, a) => s.\u6DF7\u5408\u7EC4\u5408(a));
   }
   /**
-   * 同时运行多个模型, 并提供一个函数处理它们的结果
-   * 如果其中任何一个模型发生错误, 则最终模型输出第一个错误
-   * 处理函数的类型是: 所有模型的结果合并 => 泛型A
-   * 新模型的类型是:
-   * - 参数: 所有模型的参数合并
-   * - 错误: 所有模型的错误合并
+   * 同时运行多个行为, 并提供一个函数处理它们的结果
+   * 如果其中任何一个行为发生错误, 则最终行为输出第一个错误
+   * 处理函数的类型是: 所有行为的结果合并 => 泛型A
+   * 新行为的类型是:
+   * - 参数: 所有行为的参数合并
+   * - 错误: 所有行为的错误合并
    * - 返回值: 泛型A
    */
   static \u5E76\u884C\u7EC4\u5408(arr, f) {
@@ -88,10 +88,10 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
   }
   // ================================= 组合 =================================
   /**
-   * 将两个模型串接, 得到一个新模型, 新模型的类型是:
-   * - 参数: a模型的参数
-   * - 错误: a模型的错误+b模型的错误
-   * - 返回值: b模型的返回值
+   * 将两个行为串接, 得到一个新行为, 新行为的类型是:
+   * - 参数: a行为的参数
+   * - 错误: a行为的错误+b行为的错误
+   * - 返回值: b行为的返回值
    */
   \u6D41\u5F0F\u7EC4\u5408(b) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
@@ -102,12 +102,12 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
     });
   }
   /**
-   * 将两个模型串接, 得到一个新的模型
+   * 将两个行为串接, 得到一个新的行为
    * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
-   * 新模型的类型是:
-   * - 参数: a模型的参数+(b模型的参数-a模型的返回值)
-   * - 错误: a模型的错误+b模型的错误
-   * - 返回值: a模型的返回值+b模型的返回值
+   * 新行为的类型是:
+   * - 参数: a行为的参数+(b行为的参数-a行为的返回值)
+   * - 错误: a行为的错误+b行为的错误
+   * - 返回值: a行为的返回值+b行为的返回值
    */
   \u6DF7\u5408\u7EC4\u5408(b) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
@@ -135,6 +135,13 @@ var \u4E1A\u52A1\u884C\u4E3A = class _\u4E1A\u52A1\u884C\u4E3A {
       return import_ts_fp_data.Either.pure(\u6211\u7684\u7ED3\u679C.assertRight().getRight());
     });
   }
+  /**
+   * 产生一个代数效应, 在效应中执行当前业务行为, 然后将其正确结果映射为新业务行为
+   * 新行为的类型是:
+   * - 参数: 必须是已有行为的参数的扩展, 因为调用时必须先调用已有行为
+   * - 错误: 已有行为的错误+自定义错误, 因为调用已有行为时可能出错
+   * - 返回值: 自定义数据
+   */
   \u7ED1\u5B9A(f) {
     return _\u4E1A\u52A1\u884C\u4E3A.\u901A\u8FC7\u5B9E\u73B0\u6784\u9020(async (\u53C2\u6570) => {
       const \u6211\u7684\u7ED3\u679C = await this.\u8FD0\u884C\u4E1A\u52A1\u884C\u4E3A(\u53C2\u6570);

package/dist/cjs/interface/interface-inst.d.cts

@@ -3,7 +3,7 @@ import { Either } from '@lsby/ts-fp-data';
 import { 业务行为 as ____ } from '../action/action.cjs';
 import { 合并插件结果 as ______ } from '../plugin/plug.cjs';
 import { 正确结果 as ____$1, 错误结果 as ____$2 } from '../result/result.cjs';
-import { 接口类型插件们 as _______, 接口类型错误结果 as ________, 接口类型正确结果 as ________$1, 任意接口类型 as ______$1 } from './interface-type.cjs';
+import { 接口类型插件们 as _______, 接口类型错误结果 as ________, 接口类型正确结果 as ________$1, 任意接口类型 as ______$1, 有效的接口类型 as _______$1 } from './interface-type.cjs';
 import 'express';
 
 type 计算接口参数<接口类型描述> = ______<_______<接口类型描述>>;
@@ -14,6 +14,6 @@ declare abstract class 接口<接口类型描述 extends ______$1> extends ____<
     接口实现(参数: 计算接口参数<接口类型描述>): Promise<____$1<z.infer<________$1<接口类型描述>>> | ____$2<z.infer<________<接口类型描述>>>>;
     abstract 转换业务结果到接口结果(业务结果: 计算接口返回<接口类型描述>): Promise<____$1<z.infer<________$1<接口类型描述>>> | ____$2<z.infer<________<接口类型描述>>>>;
 }
-type 任意接口 = 接口<any>;
+type 有效的接口 = 接口<_______$1>;
 
-export { type 任意接口, 接口, type 计算接口参数, type 计算接口返回 };
+export { 接口, type 有效的接口, type 计算接口参数, type 计算接口返回 };

package/dist/cjs/interface/interface-type.d.cts

@@ -8,7 +8,7 @@ type 接口类型方法<A> = A extends 接口类型<infer _A1, infer A2, infer _
 type 接口类型插件们<A> = A extends 接口类型<infer _A1, infer _A2, infer A3, infer _A4, infer _A5> ? A3 : never;
 type 接口类型正确结果<A> = A extends 接口类型<infer _A1, infer _A2, infer _A3, infer A4, infer _A5> ? A4 : never;
 type 接口类型错误结果<A> = A extends 接口类型<infer _A1, infer _A2, infer _A3, infer _A4, infer A5> ? A5 : never;
-declare class 接口类型<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确结果类型 extends z.ZodTypeAny, 错误结果类型 extends z.ZodTypeAny> {
+declare class 接口类型<路径 extends string | null, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确结果类型 extends z.ZodTypeAny, 错误结果类型 extends z.ZodTypeAny> {
     private 路径;
     private 方法;
     private 插件们;
@@ -23,6 +23,7 @@ declare class 接口类型<路径 extends string, 方法 extends 'get' | 'post',
     获得错误结果类型(): 错误结果类型;
 }
 type 任意接口类型 = 接口类型<any, any, any, any, any>;
+type 有效的接口类型 = 接口类型<string, any, any, any, any>;
 type 获得接口插件们<接口类型描述> = 接口类型描述 extends 接口类型<any, any, infer 插件, any, any> ? 插件 : never;
 
-export { type 任意接口类型, 接口类型, type 接口类型插件们, type 接口类型方法, type 接口类型正确结果, type 接口类型路径, type 接口类型错误结果, type 获得接口插件们 };
+export { type 任意接口类型, 接口类型, type 接口类型插件们, type 接口类型方法, type 接口类型正确结果, type 接口类型路径, type 接口类型错误结果, type 有效的接口类型, type 获得接口插件们 };

package/dist/cjs/plugin/extend/json.cjs

@@ -35,7 +35,6 @@ __export(json_exports, {
 module.exports = __toCommonJS(json_exports);
 var import_node_util = require("util");
 var import_express = __toESM(require("express"), 1);
-var import_zod = require("zod");
 
 // src/global/global.ts
 var import_ts_global = require("@lsby/ts-global");
@@ -64,7 +63,7 @@ var \u63D2\u4EF6 = class {
 var JSON\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
   log = Global.getItem("log");
   constructor(t, opt) {
-    super(import_zod.z.object({ body: t }), async (req, res) => {
+    super(t, async (req, res) => {
       var log = (await this.log).extend("JSON\u89E3\u6790\u63D2\u4EF6");
       await new Promise(
         (pRes, _rej) => import_express.default.json(opt)(req, res, () => {
@@ -72,12 +71,12 @@ var JSON\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
         })
       );
       await log.debug("\u51C6\u5907\u89E3\u6790 JSON\uFF1A%o", req.body);
-      const parseResult = import_zod.z.object({ body: t }).safeParse({ body: req.body });
+      const parseResult = t.safeParse(req.body);
       if (!parseResult.success) {
         await log.err("\u89E3\u6790 JSON \u5931\u8D25\uFF1A%o", parseResult.error);
         throw new Error((0, import_node_util.format)("\u89E3\u6790 JSON \u5931\u8D25: %O", parseResult.error));
       }
-      await log.debug("\u6210\u529F\u89E3\u6790 JSON\uFF1A%o", parseResult.data.body);
+      await log.debug("\u6210\u529F\u89E3\u6790 JSON\uFF1A%o", parseResult.data);
       return parseResult.data;
     });
   }

package/dist/cjs/plugin/extend/json.d.cts

@@ -4,15 +4,13 @@ import { 获得接口插件们 as _______ } from '../../interface/interface-type
 import { 插件 as __, 包装插件项 as _____, 插件项类型 as _____$1, 取Task插件内部类型 as _Task______, 合并插件结果 as ______ } from '../plug.cjs';
 import '@lsby/ts-fp-data';
 
-declare class JSON解析插件<Result extends AnyZodObject> extends __<z.ZodObject<{
-    body: Result;
-}>> {
+declare class JSON解析插件<Result extends AnyZodObject> extends __<Result> {
     private log;
     constructor(t: Result, opt: Parameters<typeof express.json>[0]);
 }
 type 任意JSON解析插件 = JSON解析插件<any>;
 type 任意JSON解析插件项 = _____<任意JSON解析插件>;
-type 合并JSON插件结果<Arr extends Array<_____$1>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<_____$1> ? 插件项 extends 任意JSON解析插件项 ? z.infer<_Task______<插件项>>['body'] & ______<xs> : 合并JSON插件结果<xs> : {} : {} : {};
+type 合并JSON插件结果<Arr extends Array<_____$1>> = Arr extends [] ? {} : Arr extends [infer x, ...infer xs] ? x extends infer 插件项 ? xs extends Array<_____$1> ? 插件项 extends 任意JSON解析插件项 ? z.infer<_Task______<插件项>> & ______<xs> : 合并JSON插件结果<xs> : {} : {} : {};
 type 从接口类型获得JSON参数<接口类型描述> = 合并JSON插件结果<_______<接口类型描述>>;
 
 export { JSON解析插件, type 从接口类型获得JSON参数, type 任意JSON解析插件, type 任意JSON解析插件项, type 合并JSON插件结果 };

package/dist/cjs/plugin/extend/urlencoded.cjs

@@ -59,10 +59,10 @@ var \u8868\u5355\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
           pRes(null);
         })
       );
-      const parseResult = t.safeParse({ body: req.body });
+      const parseResult = t.safeParse(req.body);
       if (!parseResult.success)
         throw new Error((0, import_node_util.format)("\u89E3\u6790url\u7F16\u7801\u6B63\u6587\u5931\u8D25: %O", parseResult.error));
-      return { body: parseResult.data.body };
+      return parseResult.data;
     });
   }
 };

package/dist/cjs/plugin/extend/urlencoded.d.cts

@@ -3,9 +3,7 @@ import { z } from 'zod';
 import { 插件 as __ } from '../plug.cjs';
 import '@lsby/ts-fp-data';
 
-declare class 表单解析插件<Result extends z.ZodObject<{
-    body: z.AnyZodObject;
-}>> extends __<Result> {
+declare class 表单解析插件<Result extends z.AnyZodObject> extends __<Result> {
     constructor(t: Result, opt: Parameters<typeof express.urlencoded>[0]);
 }
 

package/dist/cjs/server/server.d.cts

@@ -1,5 +1,5 @@
 import * as http from 'node:http';
-import { 任意接口 as ____ } from '../interface/interface-inst.cjs';
+import { 有效的接口 as _____ } from '../interface/interface-inst.cjs';
 import 'zod';
 import '@lsby/ts-fp-data';
 import '../action/action.cjs';
@@ -13,7 +13,7 @@ declare class 服务器 {
     private 端口;
     private 静态资源路径?;
     private log;
-    constructor(接口们: ____[], 端口: number, 静态资源路径?: string | undefined);
+    constructor(接口们: _____[], 端口: number, 静态资源路径?: string | undefined);
     run(): Promise<{
         ip: string[];
         server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/dist/esm/action/action.d.ts

@@ -54,12 +54,12 @@ declare abstract class 业务行为<参数类型 extends 业务行为参数类
      */
     static 混合组合多项<A extends 任意业务行为[]>(arr: [...A]): 计算混合组合数组<A>;
     /**
-     * 同时运行多个模型, 并提供一个函数处理它们的结果
-     * 如果其中任何一个模型发生错误, 则最终模型输出第一个错误
-     * 处理函数的类型是: 所有模型的结果合并 => 泛型A
-     * 新模型的类型是:
-     * - 参数: 所有模型的参数合并
-     * - 错误: 所有模型的错误合并
+     * 同时运行多个行为, 并提供一个函数处理它们的结果
+     * 如果其中任何一个行为发生错误, 则最终行为输出第一个错误
+     * 处理函数的类型是: 所有行为的结果合并 => 泛型A
+     * 新行为的类型是:
+     * - 参数: 所有行为的参数合并
+     * - 错误: 所有行为的错误合并
      * - 返回值: 泛型A
      */
     static 并行组合<X extends 任意业务行为[], A extends 业务行为返回类型>(arr: [...X], f: (a: 计算业务行为返回<计算合并<X>>) => Promise<A>): 业务行为<计算业务行为参数<计算合并<X>>, 计算业务行为错误<计算合并<X>>, A>;
@@ -67,23 +67,30 @@ declare abstract class 业务行为<参数类型 extends 业务行为参数类
     设置参数<A extends Partial<参数类型>>(设置参数: A): 业务行为<Omit<参数类型, keyof A>, 错误类型, 返回类型>;
     运行业务行为(参数: 参数类型): Promise<Either<错误类型, 返回类型>>;
     /**
-     * 将两个模型串接, 得到一个新模型, 新模型的类型是:
-     * - 参数: a模型的参数
-     * - 错误: a模型的错误+b模型的错误
-     * - 返回值: b模型的返回值
+     * 将两个行为串接, 得到一个新行为, 新行为的类型是:
+     * - 参数: a行为的参数
+     * - 错误: a行为的错误+b行为的错误
+     * - 返回值: b行为的返回值
      */
     流式组合<B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(b: 业务行为<返回类型, B错误类型, B返回类型>): 业务行为<参数类型, 错误类型 | B错误类型, B返回类型>;
     /**
-     * 将两个模型串接, 得到一个新的模型
+     * 将两个行为串接, 得到一个新的行为
      * 相比流式组合, 本函数不要求串联位置参数匹配, 缺少的参数将在调用时补全
-     * 新模型的类型是:
-     * - 参数: a模型的参数+(b模型的参数-a模型的返回值)
-     * - 错误: a模型的错误+b模型的错误
-     * - 返回值: a模型的返回值+b模型的返回值
+     * 新行为的类型是:
+     * - 参数: a行为的参数+(b行为的参数-a行为的返回值)
+     * - 错误: a行为的错误+b行为的错误
+     * - 返回值: a行为的返回值+b行为的返回值
      */
     混合组合<B参数类型 extends 业务行为参数类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(b: 业务行为<B参数类型, B错误类型, B返回类型>): 计算混合组合<参数类型, 错误类型, 返回类型, B参数类型, B错误类型, B返回类型>;
     映射结果<新返回类型 extends 业务行为返回类型>(f: (a: 返回类型) => 新返回类型): 业务行为<参数类型, 错误类型, 新返回类型>;
     映射错误<新错误类型 extends 业务行为错误类型>(f: (a: 错误类型) => 新错误类型): 业务行为<参数类型, 新错误类型, 返回类型>;
+    /**
+     * 产生一个代数效应, 在效应中执行当前业务行为, 然后将其正确结果映射为新业务行为
+     * 新行为的类型是:
+     * - 参数: 必须是已有行为的参数的扩展, 因为调用时必须先调用已有行为
+     * - 错误: 已有行为的错误+自定义错误, 因为调用已有行为时可能出错
+     * - 返回值: 自定义数据
+     */
     绑定<新参数类型 extends 业务行为参数类型 & 参数类型, 新错误类型 extends 错误类型 | 业务行为错误类型, 新返回类型 extends 业务行为返回类型>(f: (a: 返回类型) => 业务行为<新参数类型, 新错误类型, 新返回类型>): 业务行为<新参数类型, 新错误类型, 新返回类型>;
 }
 

package/dist/esm/action/action.js

@@ -1,6 +1,6 @@
 import {
   业务行为
-} from "../chunk-V3S5HDZD.js";
+} from "../chunk-T3WICQWT.js";
 export {
   \u4E1A\u52A1\u884C\u4E3A
 };

package/dist/esm/bin/gen-list/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "../../chunk-33UG5J6F.js";
+} from "../../chunk-G73B4M36.js";
 
 // src/bin/gen-list/bin.ts
 import path from "node:path";

package/dist/esm/bin/gen-list/index.js

@@ -1,6 +1,6 @@
 import {
   main
-} from "../../chunk-33UG5J6F.js";
+} from "../../chunk-G73B4M36.js";
 export {
   main
 };

package/dist/esm/bin/gen-test/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "../../chunk-QXOTCD4X.js";
+} from "../../chunk-GWWQPWGC.js";
 
 // src/bin/gen-test/bin.ts
 import path from "node:path";

package/dist/esm/bin/gen-test/index.js

@@ -1,6 +1,6 @@
 import {
   main
-} from "../../chunk-QXOTCD4X.js";
+} from "../../chunk-GWWQPWGC.js";
 export {
   main
 };

package/dist/esm/bin/gen-type/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "../../chunk-KFTP2JZZ.js";
+} from "../../chunk-6QNJCAAV.js";
 import "../../chunk-TW4ZMOLY.js";
 
 // src/bin/gen-type/bin.ts

package/dist/esm/bin/gen-type/index.js

@@ -1,6 +1,6 @@
 import {
   main
-} from "../../chunk-KFTP2JZZ.js";
+} from "../../chunk-6QNJCAAV.js";
 import "../../chunk-TW4ZMOLY.js";
 export {
   main

package/dist/esm/{chunk-KFTP2JZZ.js → chunk-6QNJCAAV.js}

@@ -69,15 +69,18 @@ async function main(tsconfig\u8DEF\u5F84, \u76EE\u6807\u8DEF\u5F84, \u8F93\u51FA
         `import * as ${netcore\u5F15\u5165} from '@lsby/net-core'`,
         `import { z as ${zod\u5F15\u5165} } from 'zod'`,
         `
-        type ${a.\u8BA1\u7B97\u8282\u70B9\u540D\u79F0} = typeof ${\u53D8\u91CF\u540D\u79F0} extends ${netcore\u5F15\u5165}.\u63A5\u53E3\u7C7B\u578B<infer Path, infer Method, infer PreApis, infer SuccessSchema, infer ErrorSchema>
-          ? {
-              path: Path
-              method: Method
-              input: ${netcore\u5F15\u5165}.\u5408\u5E76JSON\u63D2\u4EF6\u7ED3\u679C<PreApis>
-              successOutput: ${zod\u5F15\u5165}.infer<SuccessSchema>
-              errorOutput: ${zod\u5F15\u5165}.infer<ErrorSchema>
-            }
-          : never
+        type ${a.\u8BA1\u7B97\u8282\u70B9\u540D\u79F0} =
+          typeof ${\u53D8\u91CF\u540D\u79F0} extends ${netcore\u5F15\u5165}.\u63A5\u53E3\u7C7B\u578B<infer Path, infer Method, infer PreApis, infer SuccessSchema, infer ErrorSchema>
+            ? Path extends string
+              ? {
+                  path: Path
+                  method: Method
+                  input: ${netcore\u5F15\u5165}.\u5408\u5E76JSON\u63D2\u4EF6\u7ED3\u679C<PreApis>
+                  successOutput: ${zod\u5F15\u5165}.infer<SuccessSchema>
+                  errorOutput: ${zod\u5F15\u5165}.infer<ErrorSchema>
+                }
+              : never
+            : never
         `
       ];
     }

package/dist/esm/{chunk-AYTYZZMN.js → chunk-7OIWSU4D.js}

@@ -1,18 +1,17 @@
-import {
-  Global
-} from "./chunk-AHCV3LQ7.js";
 import {
   插件
 } from "./chunk-N4NY37XI.js";
+import {
+  Global
+} from "./chunk-AHCV3LQ7.js";
 
 // src/plugin/extend/json.ts
 import { format } from "node:util";
 import express from "express";
-import { z } from "zod";
 var JSON\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
   log = Global.getItem("log");
   constructor(t, opt) {
-    super(z.object({ body: t }), async (req, res) => {
+    super(t, async (req, res) => {
       var log = (await this.log).extend("JSON\u89E3\u6790\u63D2\u4EF6");
       await new Promise(
         (pRes, _rej) => express.json(opt)(req, res, () => {
@@ -20,12 +19,12 @@ var JSON\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
         })
       );
       await log.debug("\u51C6\u5907\u89E3\u6790 JSON\uFF1A%o", req.body);
-      const parseResult = z.object({ body: t }).safeParse({ body: req.body });
+      const parseResult = t.safeParse(req.body);
       if (!parseResult.success) {
         await log.err("\u89E3\u6790 JSON \u5931\u8D25\uFF1A%o", parseResult.error);
         throw new Error(format("\u89E3\u6790 JSON \u5931\u8D25: %O", parseResult.error));
       }
-      await log.debug("\u6210\u529F\u89E3\u6790 JSON\uFF1A%o", parseResult.data.body);
+      await log.debug("\u6210\u529F\u89E3\u6790 JSON\uFF1A%o", parseResult.data);
       return parseResult.data;
     });
   }

package/dist/esm/{chunk-AY7GYJWL.js → chunk-E7N7HVWO.js}

@@ -1,6 +1,6 @@
 import {
   业务行为
-} from "./chunk-V3S5HDZD.js";
+} from "./chunk-T3WICQWT.js";
 
 // src/interface/interface-inst.ts
 var \u63A5\u53E3 = class extends \u4E1A\u52A1\u884C\u4E3A {

package/dist/esm/{chunk-535X7O4J.js → chunk-FBFLXFIL.js}

@@ -1,6 +1,6 @@
 import {
   接口
-} from "./chunk-AY7GYJWL.js";
+} from "./chunk-E7N7HVWO.js";
 import {
   正确JSON结果,
   错误JSON结果