@lsby/net-core 0.3.12 → 0.3.13

package/dist/esm/chunk-ILSTOG4G.js

@@ -0,0 +1,30 @@
+import {
+  API接口基类
+} from "./chunk-PA2HBZKY.js";
+
+// src/interface/inst/interface.ts
+var \u63A5\u53E3 = class extends API\u63A5\u53E3\u57FA\u7C7B {
+  constructor(\u63A5\u53E3\u7C7B\u578B, \u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668, \u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668, \u5B9E\u73B0) {
+    super();
+    this.\u63A5\u53E3\u7C7B\u578B = \u63A5\u53E3\u7C7B\u578B;
+    this.\u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668 = \u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668;
+    this.\u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668 = \u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668;
+    this.\u5B9E\u73B0 = \u5B9E\u73B0;
+  }
+  \u5305\u88C5\u6B63\u786E\u7ED3\u679C(a) {
+    return this.\u6B63\u786E\u7ED3\u679C\u5305\u88C5\u5668(a);
+  }
+  \u5305\u88C5\u9519\u8BEF\u7ED3\u679C(a) {
+    return this.\u9519\u8BEF\u7ED3\u679C\u5305\u88C5\u5668(a);
+  }
+  \u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570) {
+    return this.\u5B9E\u73B0(\u53C2\u6570);
+  }
+  \u83B7\u5F97API\u7C7B\u578B() {
+    return this.\u63A5\u53E3\u7C7B\u578B;
+  }
+};
+
+export {
+  接口
+};

package/dist/esm/{chunk-X3JVDZYX.js → chunk-JIW3U7SL.js}

@@ -2,12 +2,12 @@ import {
   接口类型抽象类
 } from "./chunk-DMQXYTFQ.js";
 import {
-  正确JSON结果,
-  错误JSON结果
-} from "./chunk-IPDMEQ3O.js";
+  JSON接口基类
+} from "./chunk-I5QXSZQU.js";
 
-// src/extend/wrap-json.ts
+// src/extend/api-json-wrap.ts
 import { z } from "zod";
+import { Left, Right } from "@lsby/ts-fp-data";
 var \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B = class extends \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B {
 };
 var \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B = class extends \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B {
@@ -35,26 +35,21 @@ var \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B = class extends \u5305\u88C5\u768
     return z.object({ status: z.literal("fail"), data: this.\u9519\u8BEF\u8FD4\u56DE\u7C7B\u578B });
   }
 };
-var \u5305\u88C5\u7684\u6B63\u786EJSON\u7ED3\u679C = class extends \u6B63\u786EJSON\u7ED3\u679C {
-  constructor(data) {
-    super({
-      status: "success",
-      data
-    });
+var JSON\u63A5\u53E3\u5305\u88C5\u57FA\u7C7B = class extends JSON\u63A5\u53E3\u57FA\u7C7B {
+  \u6784\u9020\u6B63\u786E\u8FD4\u56DE(data) {
+    return new Right({ status: "success", data });
   }
-};
-var \u5305\u88C5\u7684\u9519\u8BEFJSON\u7ED3\u679C = class extends \u9519\u8BEFJSON\u7ED3\u679C {
-  constructor(data) {
-    super({
-      status: "fail",
-      data
-    });
+  \u6784\u9020\u9519\u8BEF\u8FD4\u56DE(data) {
+    return new Left({ status: "fail", data });
+  }
+  \u6784\u9020\u5305\u88C5\u8FD4\u56DE(data) {
+    if (data.isLeft()) return new Left({ status: "fail", data: data.assertLeft().getLeft() });
+    return new Right({ status: "success", data: data.assertRight().getRight() });
   }
 };
 
 export {
   包装的接口类型抽象类,
   包装的接口类型,
-  包装的正确JSON结果,
-  包装的错误JSON结果
+  JSON接口包装基类
 };

package/dist/esm/{chunk-CSZNLNB5.js → chunk-NCSYD5GL.js}

@@ -41,8 +41,7 @@ async function main(tsconfigPath, interfaceFolderPath, outFilePath, filter) {
   const testCode = [];
   for (var index = 0; index < testSourceFilesFilter.length; index++) {
     var testSourceFile = testSourceFilesFilter[index];
-    if (testSourceFile == null)
-      throw new Error("\u975E\u9884\u671F\u7684\u6570\u7EC4\u8D8A\u754C");
+    if (testSourceFile == null) throw new Error("\u975E\u9884\u671F\u7684\u6570\u7EC4\u8D8A\u754C");
     const filenameRelativeToApiFolder = path.relative(interfaceFolderPath, testSourceFile.fileName).replaceAll("\\", "/");
     const importName = filenameRelativeToApiFolder.replaceAll("/", "_").replaceAll(".test.ts", "").replaceAll("./", "").replaceAll("-", "_");
     const filenameRelativeToProjectRoot = path.relative(projectRootPath, testSourceFile.fileName).replaceAll("\\", "/").replaceAll(".ts", "");

package/dist/esm/chunk-PA2HBZKY.js

@@ -0,0 +1,16 @@
+import {
+  业务行为
+} from "./chunk-HOO4TK2L.js";
+
+// src/interface/inst/interface-abstract.ts
+var API\u63A5\u53E3\u57FA\u7C7B = class extends \u4E1A\u52A1\u884C\u4E3A {
+  async API\u5B9E\u73B0(\u53C2\u6570) {
+    var c = await this.\u4E1A\u52A1\u884C\u4E3A\u5B9E\u73B0(\u53C2\u6570);
+    if (c.isLeft()) return this.\u5305\u88C5\u9519\u8BEF\u7ED3\u679C(c.assertLeft().getLeft());
+    return this.\u5305\u88C5\u6B63\u786E\u7ED3\u679C(c.assertRight().getRight());
+  }
+};
+
+export {
+  API接口基类
+};

package/dist/esm/{chunk-5UUMGDDD.js → chunk-TMFRIHV5.js}

@@ -14,8 +14,7 @@ var \u8868\u5355\u89E3\u6790\u63D2\u4EF6 = class extends \u63D2\u4EF6 {
         })
       );
       const parseResult = t.safeParse({ body: req.body });
-      if (!parseResult.success)
-        throw new Error(format("parse url encoded body failed: %O", parseResult.error));
+      if (!parseResult.success) throw new Error(format("parse url encoded body failed: %O", parseResult.error));
       return { body: parseResult.data.body };
     });
   }

package/dist/esm/extend/api-json-base.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { API接口基类 as API____ } from '../interface/inst/interface-abstract.js';
+import { 任意接口类型 as ______, 接口类型正确结果 as ________, 接口类型错误结果 as ________$1 } from '../interface/type/interface-type-abstract.js';
+import { 正确结果 as ____, 错误结果 as ____$1 } from '../result/result.js';
+import '@lsby/ts-fp-data';
+import '../interface/action/action.js';
+import '../interface/plug.js';
+import 'express';
+
+declare abstract class JSON接口基类<接口类型描述 extends ______> extends API____<接口类型描述> {
+    protected 包装正确结果(数据: z.infer<________<接口类型描述>>): ____<z.infer<________<接口类型描述>>>;
+    protected 包装错误结果(数据: z.infer<________$1<接口类型描述>>): ____$1<z.infer<________$1<接口类型描述>>>;
+}
+
+export { JSON接口基类 };

package/dist/esm/extend/api-json-base.js

@@ -0,0 +1,10 @@
+import {
+  JSON接口基类
+} from "../chunk-I5QXSZQU.js";
+import "../chunk-PA2HBZKY.js";
+import "../chunk-HOO4TK2L.js";
+import "../chunk-IPDMEQ3O.js";
+import "../chunk-AHCV3LQ7.js";
+export {
+  JSON\u63A5\u53E3\u57FA\u7C7B
+};

package/dist/esm/extend/{wrap-json.d.ts → api-json-wrap.d.ts}

@@ -1,9 +1,12 @@
 import { z } from 'zod';
+import { Either } from '@lsby/ts-fp-data';
 import { 插件项类型 as _____ } from '../interface/plug.js';
-import { 接口类型抽象类 as _______ } from '../interface/type/interface-type-abstract.js';
-import { 正确JSON结果 as __JSON__, 错误JSON结果 as __JSON__$1 } from '../result/result.js';
+import { 接口类型抽象类 as _______, 接口类型错误结果 as ________, 接口类型正确结果 as ________$1 } from '../interface/type/interface-type-abstract.js';
+import { JSON接口基类 as JSON____ } from './api-json-base.js';
 import 'express';
-import '@lsby/ts-fp-data';
+import '../interface/inst/interface-abstract.js';
+import '../result/result.js';
+import '../interface/action/action.js';
 
 declare abstract class 包装的接口类型抽象类<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确返回类型 extends z.ZodTypeAny, 错误返回类型 extends z.ZodTypeAny> extends _______<路径, 方法, 插件们, z.ZodObject<{
     status: z.ZodLiteral<'success'>;
@@ -24,6 +27,9 @@ declare abstract class 包装的接口类型抽象类<路径 extends string, 方
         data: 错误返回类型;
     }>;
 }
+type 任意的包装的接口类型 = 包装的接口类型抽象类<any, any, any, any, any>;
+type 取返回类型<A> = A extends 包装的接口类型抽象类<any, any, any, infer X, any> ? X : never;
+type 取错误类型<A> = A extends 包装的接口类型抽象类<any, any, any, any, infer X> ? X : never;
 declare class 包装的接口类型<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确返回类型 extends z.ZodTypeAny, 错误返回类型 extends z.ZodTypeAny> extends 包装的接口类型抽象类<路径, 方法, 插件们, 正确返回类型, 错误返回类型> {
     private path;
     private method;
@@ -43,17 +49,10 @@ declare class 包装的接口类型<路径 extends string, 方法 extends 'get'
         data: 错误返回类型;
     }>;
 }
-declare class 包装的正确JSON结果<Data> extends __JSON__<{
-    status: 'success';
-    data: Data;
-}> {
-    constructor(data: Data);
-}
-declare class 包装的错误JSON结果<Data> extends __JSON__$1<{
-    status: 'fail';
-    data: Data;
-}> {
-    constructor(data: Data);
+declare abstract class JSON接口包装基类<接口类型描述 extends 任意的包装的接口类型> extends JSON____<接口类型描述> {
+    protected 构造正确返回(data: z.infer<取返回类型<接口类型描述>>): Either<z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>>;
+    protected 构造错误返回(data: z.infer<取错误类型<接口类型描述>>): Either<z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>>;
+    protected 构造包装返回(data: Either<z.infer<取错误类型<接口类型描述>>, z.infer<取返回类型<接口类型描述>>>): Either<z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>>;
 }
 
-export { 包装的接口类型, 包装的接口类型抽象类, 包装的正确JSON结果, 包装的错误JSON结果 };
+export { JSON接口包装基类, 包装的接口类型, 包装的接口类型抽象类 };

package/dist/esm/extend/api-json-wrap.js

@@ -0,0 +1,16 @@
+import {
+  JSON接口包装基类,
+  包装的接口类型,
+  包装的接口类型抽象类
+} from "../chunk-JIW3U7SL.js";
+import "../chunk-DMQXYTFQ.js";
+import "../chunk-I5QXSZQU.js";
+import "../chunk-PA2HBZKY.js";
+import "../chunk-HOO4TK2L.js";
+import "../chunk-IPDMEQ3O.js";
+import "../chunk-AHCV3LQ7.js";
+export {
+  JSON\u63A5\u53E3\u5305\u88C5\u57FA\u7C7B,
+  \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B,
+  \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B
+};

package/dist/esm/index.d.ts

@@ -1,8 +1,9 @@
-export { 包装的接口类型, 包装的接口类型抽象类, 包装的正确JSON结果, 包装的错误JSON结果 } from './extend/wrap-json.js';
+export { JSON接口基类 } from './extend/api-json-base.js';
+export { JSON接口包装基类, 包装的接口类型, 包装的接口类型抽象类 } from './extend/api-json-wrap.js';
 export { 接口 } from './interface/inst/interface.js';
-export { API接口基类, 任意接口, 计算实现参数, 计算实现结果 } from './interface/inst/interface-abstract.js';
+export { API接口基类, 任意接口, 计算实现参数, 计算实现返回 } from './interface/inst/interface-abstract.js';
 export { 接口类型 } from './interface/type/interface-type.js';
-export { 任意接口类型, 接口类型抽象类, 获得接口插件们 } from './interface/type/interface-type-abstract.js';
+export { 任意接口类型, 接口类型抽象类, 接口类型插件们, 接口类型方法, 接口类型正确结果, 接口类型路径, 接口类型错误结果, 获得接口插件们 } from './interface/type/interface-type-abstract.js';
 export { 任意插件, 包装插件项, 取插件内部类型, 合并插件结果, 插件, 插件项类型 } from './interface/plug.js';
 export { 中文路径支持插件 } from './plugin/chinese-path.js';
 export { 自定义数据插件 } from './plugin/custom-data.js';
@@ -13,6 +14,7 @@ export { 服务器 } from './server/server.js';
 export { 测试 } from './test/test.js';
 export { 测试抽象类 } from './test/test-abstract.js';
 import 'zod';
-import 'express';
 import '@lsby/ts-fp-data';
+import './interface/action/action.js';
+import 'express';
 import 'node:http';

package/dist/esm/index.js

@@ -1,15 +1,15 @@
-import {
-  接口
-} from "./chunk-TFOAFRUL.js";
-import {
-  API接口基类
-} from "./chunk-N2AO545F.js";
 import {
   接口类型
 } from "./chunk-CMHISRDG.js";
+import {
+  接口
+} from "./chunk-ILSTOG4G.js";
+import {
+  表单解析插件
+} from "./chunk-TMFRIHV5.js";
 import {
   服务器
-} from "./chunk-N7VWAPFU.js";
+} from "./chunk-6NX5P6CE.js";
 import {
   测试
 } from "./chunk-PIYVLQLM.js";
@@ -17,14 +17,20 @@ import {
   测试抽象类
 } from "./chunk-XRV64MDF.js";
 import {
+  JSON接口包装基类,
   包装的接口类型,
-  包装的接口类型抽象类,
-  包装的正确JSON结果,
-  包装的错误JSON结果
-} from "./chunk-X3JVDZYX.js";
+  包装的接口类型抽象类
+} from "./chunk-JIW3U7SL.js";
 import {
   接口类型抽象类
 } from "./chunk-DMQXYTFQ.js";
+import {
+  JSON接口基类
+} from "./chunk-I5QXSZQU.js";
+import {
+  API接口基类
+} from "./chunk-PA2HBZKY.js";
+import "./chunk-HOO4TK2L.js";
 import {
   正确JSON结果,
   正确结果,
@@ -43,20 +49,17 @@ import {
   JSON解析插件
 } from "./chunk-VJ4ORZR3.js";
 import "./chunk-AHCV3LQ7.js";
-import {
-  表单解析插件
-} from "./chunk-5UUMGDDD.js";
 import {
   插件
 } from "./chunk-KSZE2DTR.js";
 export {
   API\u63A5\u53E3\u57FA\u7C7B,
+  JSON\u63A5\u53E3\u5305\u88C5\u57FA\u7C7B,
+  JSON\u63A5\u53E3\u57FA\u7C7B,
   JSON\u89E3\u6790\u63D2\u4EF6,
   \u4E2D\u6587\u8DEF\u5F84\u652F\u6301\u63D2\u4EF6,
   \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B,
   \u5305\u88C5\u7684\u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B,
-  \u5305\u88C5\u7684\u6B63\u786EJSON\u7ED3\u679C,
-  \u5305\u88C5\u7684\u9519\u8BEFJSON\u7ED3\u679C,
   \u63A5\u53E3,
   \u63A5\u53E3\u7C7B\u578B,
   \u63A5\u53E3\u7C7B\u578B\u62BD\u8C61\u7C7B,

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

@@ -0,0 +1,90 @@
+import { Either } from '@lsby/ts-fp-data';
+
+type 业务行为错误类型 = string | never;
+type 业务行为参数类型 = Record<string, any>;
+type 业务行为返回类型 = Record<string, any>;
+type 任意业务行为 = 业务行为<any, any, any>;
+type 计算混合组合<A参数类型 extends 业务行为参数类型, A错误类型 extends 业务行为错误类型, A返回类型 extends 业务行为返回类型, B参数类型 extends 业务行为参数类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型> = 业务行为<A参数类型 & Omit<B参数类型, keyof A返回类型>, A错误类型 | B错误类型, A返回类型 & B返回类型>;
+type 计算混合单一组合<A, B> = A extends 业务行为<infer A参数, infer A错误, infer A返回> ? B extends 业务行为<infer B参数, infer B错误, infer B返回> ? 计算混合组合<A参数, A错误, A返回, B参数, B错误, B返回> : never : never;
+type 计算混合组合数组<Arr> = Arr extends [infer x, infer y] ? 计算混合单一组合<x, y> : Arr extends [infer x, infer y, ...infer s] ? 计算混合组合数组<[计算混合单一组合<x, y>, ...s]> : never;
+type 计算合并<Arr> = Arr extends [] ? 业务行为<{}, never, {}> : Arr extends [infer x, ...infer xs] ? x extends 业务行为<infer 参数1, infer 错误1, infer 返回1> ? 计算合并<xs> extends 业务行为<infer 参数2, infer 错误2, infer 返回2> ? 业务行为<参数1 & 参数2, 错误1 | 错误2, 返回1 & 返回2> : never : never : never;
+type 取参数<A> = A extends 业务行为<infer 参数, infer _错误, infer _返回> ? 参数 : never;
+type 取错误<A> = A extends 业务行为<infer _参数, infer 错误, infer _返回> ? 错误 : never;
+type 取返回<A> = A extends 业务行为<infer _参数, infer _错误, infer 返回> ? 返回 : never;
+/**
+ * ## 业务行为
+ *
+ * 业务行为是代码中业务逻辑的抽象表示
+ * 其本质是一个执行特定业务逻辑的函数
+ * 其特点是:
+ * - 业务相关: 比起普通函数, 特化了一部分逻辑, 以更好的适应业务逻辑的需要
+ * - 类型安全: 遵循 先类型 后实现 的原则
+ * - 可组合: 基于该模型, 可以创建出各种具有想象力的组合模式
+ *
+ * ## 实现
+ *
+ * 对于业务行为而言, 至少应该明确:
+ * - 参数: 该函数需要的信息
+ * - 错误: 该函数可能发生的错误
+ * - 返回: 该函数正确执行时返回的数据
+ *
+ * 当编写一个业务行为时, 必须先明确以上值的类型, 然后继承该基类进行实现
+ *
+ * 实现中, 可以获得参数.
+ * 实现中, 必须返回一个左值或一个右值, 当然也可能意外抛出错误
+ * 当意外的抛出错误时, 会原封不动的抛出错误
+ *
+ * ## 组合
+ *
+ * 可以将业务逻辑进行组合, 创造出新的业务逻辑
+ *
+ * ## 使用
+ *
+ * 通过`运行业务行为`来执行该业务行为
+ * 这将会得到实现中返回的结果
+ */
+declare abstract class 业务行为<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型> {
+    static 通过实现构造<参数类型 extends 业务行为参数类型, 错误类型 extends 业务行为错误类型, 返回类型 extends 业务行为返回类型>(实现: (参数: 参数类型) => Promise<Either<错误类型, 返回类型>>, 业务行为名称?: string): 业务行为<参数类型, 错误类型, 返回类型>;
+    static 流式组合<A参数类型 extends 业务行为参数类型, A错误类型 extends 业务行为错误类型, A返回类型 extends 业务行为返回类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(a: 业务行为<A参数类型, A错误类型, A返回类型>, b: 业务行为<A返回类型, B错误类型, B返回类型>): 业务行为<A参数类型, A错误类型 | B错误类型, B返回类型>;
+    static 混合组合<A参数类型 extends 业务行为参数类型, A错误类型 extends 业务行为错误类型, A返回类型 extends 业务行为返回类型, B参数类型 extends 业务行为参数类型, B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(a: 业务行为<A参数类型, A错误类型, A返回类型>, b: 业务行为<B参数类型, B错误类型, B返回类型>): 计算混合组合<A参数类型, A错误类型, A返回类型, B参数类型, B错误类型, B返回类型>;
+    /**
+     * 对多个项混合组合
+     */
+    static 混合组合多项<A extends 任意业务行为[]>(arr: [...A]): 计算混合组合数组<A>;
+    /**
+     * 同时运行多个模型, 并提供一个函数处理它们的结果
+     * 如果其中任何一个模型发生错误, 则最终模型输出第一个错误
+     * 处理函数的类型是: 所有模型的结果合并 => 泛型A
+     * 新模型的类型是:
+     * - 参数: 所有模型的参数合并
+     * - 错误: 所有模型的错误合并
+     * - 返回值: 泛型A
+     */
+    static 并行组合<X extends 任意业务行为[], A extends 业务行为返回类型>(arr: [...X], f: (a: 取返回<计算合并<X>>) => Promise<A>): 业务行为<取参数<计算合并<X>>, 取错误<计算合并<X>>, A>;
+    private 业务行为名称;
+    constructor(业务行为名称?: string);
+    protected abstract 业务行为实现(参数: 参数类型): Promise<Either<错误类型, 返回类型>>;
+    设置业务行为名称(业务行为名称: string): this;
+    设置参数<A extends Partial<参数类型>>(设置参数: A): 业务行为<Omit<参数类型, keyof A>, 错误类型, 返回类型>;
+    运行业务行为(参数: 参数类型): Promise<Either<错误类型, 返回类型>>;
+    /**
+     * 将两个模型串接, 得到一个新模型, 新模型的类型是:
+     * - 参数: a模型的参数
+     * - 错误: a模型的错误+b模型的错误
+     * - 返回值: b模型的返回值
+     */
+    流式组合<B错误类型 extends 业务行为错误类型, B返回类型 extends 业务行为返回类型>(b: 业务行为<返回类型, B错误类型, B返回类型>): 业务行为<参数类型, 错误类型 | B错误类型, 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: 错误类型) => 新错误类型): 业务行为<参数类型, 新错误类型, 返回类型>;
+}
+
+export { 业务行为, type 业务行为参数类型, type 业务行为返回类型, type 业务行为错误类型 };

package/dist/esm/interface/action/action.js

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

package/dist/esm/interface/inst/interface-abstract.d.ts

@@ -1,19 +1,20 @@
 import { z } from 'zod';
-import { 正确结果 as ____, 错误结果 as ____$1 } from '../../result/result.js';
+import { Either } from '@lsby/ts-fp-data';
+import { 正确结果 as ____$1, 错误结果 as ____$2 } from '../../result/result.js';
+import { 业务行为 as ____ } from '../action/action.js';
 import { 合并插件结果 as ______ } from '../plug.js';
-import { 任意接口类型 as ______$1, 接口类型抽象类 as _______ } from '../type/interface-type-abstract.js';
+import { 接口类型插件们 as _______, 接口类型错误结果 as ________, 接口类型正确结果 as ________$1, 任意接口类型 as ______$1 } from '../type/interface-type-abstract.js';
 import 'express';
-import '@lsby/ts-fp-data';
 
-type F3<A> = A extends _______<infer _A1, infer _A2, infer A3, infer _A4, infer _A5> ? A3 : never;
-type F4<A> = A extends _______<infer _A1, infer _A2, infer _A3, infer A4, infer _A5> ? A4 : never;
-type F5<A> = A extends _______<infer _A1, infer _A2, infer _A3, infer _A4, infer A5> ? A5 : never;
-type 计算实现参数<接口类型定义> = ______<F3<接口类型定义>>;
-type 计算实现结果<接口类型定义> = Promise<____<z.infer<F4<接口类型定义>>> | ____$1<z.infer<F5<接口类型定义>>>>;
-declare abstract class API接口基类<接口类型描述 extends ______$1> {
+type 计算实现参数<接口类型描述> = ______<_______<接口类型描述>>;
+type 计算实现返回<接口类型描述> = Promise<Either<z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>>>;
+declare abstract class API接口基类<接口类型描述 extends ______$1> extends ____<计算实现参数<接口类型描述>, z.infer<________<接口类型描述>>, z.infer<________$1<接口类型描述>>> {
+    protected abstract 业务行为实现(参数: 计算实现参数<接口类型描述>): 计算实现返回<接口类型描述>;
+    protected abstract 包装正确结果(数据: z.infer<________$1<接口类型描述>>): ____$1<z.infer<________$1<接口类型描述>>>;
+    protected abstract 包装错误结果(数据: z.infer<________<接口类型描述>>): ____$2<z.infer<________<接口类型描述>>>;
     abstract 获得API类型(): 接口类型描述;
-    abstract API实现(ctx: ______<F3<接口类型描述>>): Promise<____<z.infer<F4<接口类型描述>>> | ____$1<z.infer<F5<接口类型描述>>>>;
+    API实现(参数: 计算实现参数<接口类型描述>): Promise<____$1<z.infer<________$1<接口类型描述>>> | ____$2<z.infer<________<接口类型描述>>>>;
 }
 type 任意接口 = API接口基类<any>;
 
-export { API接口基类, type 任意接口, type 计算实现参数, type 计算实现结果 };
+export { API接口基类, type 任意接口, type 计算实现参数, type 计算实现返回 };

package/dist/esm/interface/inst/interface-abstract.js

@@ -1,6 +1,7 @@
 import {
   API接口基类
-} from "../../chunk-N2AO545F.js";
+} from "../../chunk-PA2HBZKY.js";
+import "../../chunk-HOO4TK2L.js";
 export {
   API\u63A5\u53E3\u57FA\u7C7B
 };

package/dist/esm/interface/inst/interface.d.ts

@@ -1,18 +1,22 @@
 import { z } from 'zod';
+import { Either } from '@lsby/ts-fp-data';
 import { 正确结果 as ____, 错误结果 as ____$1 } from '../../result/result.js';
 import { 插件项类型 as _____, 合并插件结果 as ______ } from '../plug.js';
-import { 接口类型抽象类 as _______ } from '../type/interface-type-abstract.js';
+import { 接口类型抽象类 as _______, 接口类型错误结果 as ________, 接口类型正确结果 as ________$1 } from '../type/interface-type-abstract.js';
 import { API接口基类 as API____ } from './interface-abstract.js';
 import 'express';
-import '@lsby/ts-fp-data';
+import '../action/action.js';
 
 declare class 接口<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确返回类型 extends z.ZodTypeAny, 错误返回类型 extends z.ZodTypeAny> extends API____<_______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>> {
     private 接口类型;
+    private 正确结果包装器;
+    private 错误结果包装器;
     private 实现;
-    protected readonly __类型保持符号?: [路径, 方法, 插件们, 正确返回类型, 错误返回类型];
-    constructor(接口类型: _______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>, 实现: (插件结果: ______<插件们>) => Promise<____<z.infer<正确返回类型>> | ____$1<z.infer<错误返回类型>>>);
+    constructor(接口类型: _______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>, 正确结果包装器: (a: z.infer<________<_______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>>>) => ____<z.infer<________$1<_______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>>>>, 错误结果包装器: (a: z.infer<________$1<_______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>>>) => ____$1<z.infer<________<_______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>>>>, 实现: (插件结果: ______<插件们>) => Promise<Either<z.infer<错误返回类型>, z.infer<正确返回类型>>>);
+    protected 包装正确结果(a: z.infer<错误返回类型>): ____<z.infer<正确返回类型>>;
+    protected 包装错误结果(a: z.infer<正确返回类型>): ____$1<z.infer<错误返回类型>>;
+    protected 业务行为实现(参数: ______<插件们>): Promise<Either<z.infer<错误返回类型>, z.infer<正确返回类型>>>;
     获得API类型(): _______<路径, 方法, 插件们, 正确返回类型, 错误返回类型>;
-    API实现(ctx: ______<插件们>): Promise<____<z.TypeOf<正确返回类型>> | ____$1<z.TypeOf<错误返回类型>>>;
 }
 
 export { 接口 };

package/dist/esm/interface/inst/interface.js

@@ -1,7 +1,8 @@
 import {
   接口
-} from "../../chunk-TFOAFRUL.js";
-import "../../chunk-N2AO545F.js";
+} from "../../chunk-ILSTOG4G.js";
+import "../../chunk-PA2HBZKY.js";
+import "../../chunk-HOO4TK2L.js";
 export {
   \u63A5\u53E3
 };

package/dist/esm/interface/type/interface-type-abstract.d.ts

@@ -3,6 +3,11 @@ import { 插件项类型 as _____ } from '../plug.js';
 import 'express';
 import '@lsby/ts-fp-data';
 
+type 接口类型路径<A> = A extends 接口类型抽象类<infer A1, infer _A2, infer _A3, infer _A4, infer _A5> ? A1 : never;
+type 接口类型方法<A> = A extends 接口类型抽象类<infer _A1, infer A2, infer _A3, infer _A4, infer _A5> ? A2 : never;
+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 abstract class 接口类型抽象类<路径 extends string, 方法 extends 'get' | 'post', 插件们 extends Array<_____>, 正确结果类型 extends z.ZodTypeAny, 错误结果类型 extends z.ZodTypeAny> {
     abstract 获得路径(): 路径;
     abstract 获得方法(): 方法;
@@ -13,4 +18,4 @@ declare abstract class 接口类型抽象类<路径 extends string, 方法 exten
 type 任意接口类型 = 接口类型抽象类<any, any, any, any, any>;
 type 获得接口插件们<接口类型描述> = 接口类型描述 extends 接口类型抽象类<any, any, infer 插件, any, any> ? 插件 : never;
 
-export { type 任意接口类型, 接口类型抽象类, type 获得接口插件们 };
+export { type 任意接口类型, 接口类型抽象类, type 接口类型插件们, type 接口类型方法, type 接口类型正确结果, type 接口类型路径, type 接口类型错误结果, type 获得接口插件们 };

package/dist/esm/plugin/urlencoded.js

@@ -1,6 +1,6 @@
 import {
   表单解析插件
-} from "../chunk-5UUMGDDD.js";
+} from "../chunk-TMFRIHV5.js";
 import "../chunk-KSZE2DTR.js";
 export {
   \u8868\u5355\u89E3\u6790\u63D2\u4EF6

package/dist/esm/server/server.d.ts

@@ -1,10 +1,11 @@
 import * as http from 'node:http';
 import { 任意接口 as ____ } from '../interface/inst/interface-abstract.js';
 import 'zod';
+import '@lsby/ts-fp-data';
 import '../result/result.js';
 import 'express';
+import '../interface/action/action.js';
 import '../interface/plug.js';
-import '@lsby/ts-fp-data';
 import '../interface/type/interface-type-abstract.js';
 
 declare class 服务器 {

package/dist/esm/server/server.js

@@ -1,6 +1,6 @@
 import {
   服务器
-} from "../chunk-N7VWAPFU.js";
+} from "../chunk-6NX5P6CE.js";
 import "../chunk-AHCV3LQ7.js";
 export {
   \u670D\u52A1\u5668