@x-oasis/async-call-rpc 0.1.38

package/dist/middlewares/updateSeqInfo.d.ts

@@ -0,0 +1,6 @@
+import { SenderMiddlewareOutput, SendMiddlewareLifecycle } from '../types';
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+export declare const updateSeqInfo: (channelProtocol: AbstractChannelProtocol) => {
+    (value: SenderMiddlewareOutput): SenderMiddlewareOutput;
+    lifecycle: SendMiddlewareLifecycle;
+};

package/dist/middlewares/utils.d.ts

@@ -0,0 +1,3 @@
+import { MiddlewareContext, PendingSendEntry } from '../types';
+export declare const resumeMiddlewares: (middlewares: any, entry: PendingSendEntry) => any;
+export declare const runMiddlewares: (middlewares: any, args: any[], _context?: MiddlewareContext) => any;

package/dist/protocol/AbstractChannelProtocol.d.ts

@@ -0,0 +1,55 @@
+import { Disposable } from '@x-oasis/disposable';
+import { Deferred } from '@x-oasis/deferred';
+import { SendingProps, IMessageChannel, ClientMiddleware, SenderMiddleware, PendingSendEntry, AbstractChannelProtocolProps } from '../types';
+import ReadBaseBuffer from '../buffer/ReadBaseBuffer';
+import WriteBaseBuffer from '../buffer/WriteBaseBuffer';
+import RPCService from '../endpoint/RPCService';
+declare abstract class AbstractChannelProtocol extends Disposable implements IMessageChannel {
+    private readonly _masterProcessName;
+    private _key;
+    private _service;
+    private readonly _description;
+    private _seqId;
+    protected _onMessageMiddleware: ClientMiddleware[];
+    private _senderMiddleware;
+    private _readBuffer;
+    private _writeBuffer;
+    private _serializationFormat;
+    private _isConnected;
+    ongoingRequests: Map<string, Deferred>;
+    pendingSendEntries: Set<PendingSendEntry>;
+    requestEvents: Map<string, any>;
+    private onDidConnectedEvent;
+    onDidConnected: (listener: Function) => import("@x-oasis/disposable").IDisposable;
+    private onDidDisconnectedEvent;
+    onDidDisconnected: (listener: Function) => import("@x-oasis/disposable").IDisposable;
+    constructor(props?: AbstractChannelProtocolProps);
+    get service(): RPCService;
+    setService(service: RPCService): void;
+    get senderMiddleware(): any[];
+    get readBuffer(): ReadBaseBuffer;
+    get writeBuffer(): WriteBaseBuffer;
+    get serializationFormat(): string;
+    setSerializationFormat(format: string): void;
+    get seqId(): string;
+    get description(): string;
+    get masterProcessName(): string;
+    addPendingSendEntry(entry: PendingSendEntry): void;
+    decorateSendMiddleware(middlewares: SenderMiddleware[]): any[];
+    decorateOnMessageMiddleware(middlewares: ClientMiddleware[]): any[];
+    applyOnMessageMiddleware(fns: Function | Function[]): void;
+    applySendMiddleware(fns: Function | Function[]): void;
+    isConnected(): boolean;
+    send(..._args: any[]): void;
+    on(..._args: any[]): void;
+    resumePendingEntry(): void;
+    didConnected(): void;
+    connect(): void;
+    activate(): void;
+    disconnect(): void;
+    makeRequest(props: SendingProps, transfer?: MessagePort[]): Deferred | void;
+    makeRequest(requestPath: string, fnName: string, ...args: any[]): Deferred | void;
+    sendReply(...args: any[]): void;
+    onMessage(...args: any[]): void;
+}
+export default AbstractChannelProtocol;

package/dist/protocol/MessageChannel.d.ts

@@ -0,0 +1,18 @@
+import { IMessageChannel, AbstractChannelProtocolProps } from '../types/channel';
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { SenderMiddleware, ClientMiddleware } from '../types';
+export default class RPCMessageChannel extends AbstractChannelProtocol implements IMessageChannel {
+    private readonly port;
+    private sender;
+    private targetOrigin;
+    constructor(options: {
+        port: MessagePort;
+        sender?: any;
+        targetOrigin?: string;
+    } & AbstractChannelProtocolProps);
+    on(listener: (event: MessageEvent) => void): void | (() => void);
+    send(message: any, transfer?: Transferable[]): void;
+    decorateSendMiddleware(middlewares: SenderMiddleware[]): any[];
+    decorateOnMessageMiddleware(middlewares: ClientMiddleware[]): any[];
+    disconnect(): void;
+}

package/dist/protocol/WebSocketChannel.d.ts

@@ -0,0 +1,23 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { SenderMiddleware, ClientMiddleware, AbstractChannelProtocolProps } from '../types';
+export default class WebSocketChannel extends AbstractChannelProtocol {
+    private socket;
+    readonly name: string;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    constructor(socket: WebSocket, options?: {
+        name?: string;
+        maxReconnectAttempts?: number;
+        reconnectDelay?: number;
+        connected?: boolean;
+    } & AbstractChannelProtocolProps);
+    private setupSocketHandlers;
+    on(listener: (data: unknown) => void): void | (() => void);
+    send(data: unknown): void;
+    decorateSendMiddleware(middlewares: SenderMiddleware[]): any[];
+    decorateOnMessageMiddleware(middlewares: ClientMiddleware[]): any[];
+    disconnect(): void;
+    get readyState(): number;
+    isOpen(): boolean;
+}

package/dist/protocol/WorkerChannel.d.ts

@@ -0,0 +1,11 @@
+import AbstractChannelProtocol from './AbstractChannelProtocol';
+import { AbstractChannelProtocolProps } from '../types/channel';
+export default class WorkerChannel extends AbstractChannelProtocol {
+    private worker;
+    readonly name: string;
+    constructor(worker: any, options?: {
+        name?: string;
+    } & AbstractChannelProtocolProps);
+    on(listener: (data: unknown) => void): void | (() => void);
+    send(data: unknown): void;
+}

package/dist/types/buffer.d.ts

@@ -0,0 +1,4 @@
+export declare type DataBuffer = {
+    flush: () => void;
+    drain: () => void;
+};

package/dist/types/channel.d.ts

@@ -0,0 +1,27 @@
+export declare type IMessageChannelOnClose = () => void;
+export declare type IMessageChannelOnError = () => void;
+export declare type IMessageChannelOnMessage = (message: any) => void;
+export declare type IMessageChannelSend = (options: any) => void;
+export declare type IMessageChannelDisconnect = () => void;
+export declare type IMessageChannel = {
+    onClose?: IMessageChannelOnClose;
+    onError?: IMessageChannelOnError;
+    onMessage: IMessageChannelOnMessage;
+    send: IMessageChannelSend;
+    disconnect: IMessageChannelDisconnect;
+};
+export declare type SendingProps = {
+    requestPath: string;
+    methodName: string;
+    args?: any[];
+    isOptionsRequest?: boolean;
+    transfer?: MessagePort[];
+};
+export declare type AbstractChannelProtocolProps = {
+    description?: string;
+    masterProcessName?: string;
+    connected?: boolean;
+    serializationFormat?: string;
+    readBuffer?: any;
+    writeBuffer?: any;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './channel';
+export * from './rpc';
+export * from './proxyChannel';
+export * from './proxyService';
+export * from './middleware';
+export declare type ClientMiddleware = any;
+export declare type SenderMiddleware = any;

package/dist/types/middleware.d.ts

@@ -0,0 +1,44 @@
+import { Deferred } from '@x-oasis/deferred';
+import { HostRequestEntry, RequestEntry } from './rpc';
+export declare type MiddlewareFunction = {
+    (...args: any[]): any;
+    displayName?: string;
+    lifecycle?: SendMiddlewareLifecycle;
+};
+export declare type MessageOutput = {
+    event: any;
+    ports: any;
+};
+export declare type NormalizedRawMessageOutput = MessageOutput & {
+    data: string;
+};
+export declare type DeserializedMessageOutput = MessageOutput & {
+    data: HostRequestEntry | RequestEntry;
+};
+export declare type SenderMiddlewareOutput = {
+    data: any;
+    transfer: any;
+    seqId: number;
+    returnValue: Deferred;
+    isOptionsRequest: boolean;
+    middlewareContext: MiddlewareContext;
+};
+export declare type PendingSendEntry = SenderMiddlewareOutput & {
+    methodName: string;
+    lifecycle: SendMiddlewareLifecycle;
+    middlewareContext: MiddlewareContext;
+};
+export declare type MiddlewareContext = {
+    isResumed?: boolean;
+    startLifecycle: SendMiddlewareLifecycle;
+    minLifecycle: SendMiddlewareLifecycle;
+    reserved: PendingSendEntry;
+};
+export declare enum SendMiddlewareLifecycle {
+    Initial = 0,
+    Prepare = 10,
+    Transform = 20,
+    DataOperation = 30,
+    Send = 40,
+    Aborted = 100
+}

package/dist/types/proxyChannel.d.ts

@@ -0,0 +1,3 @@
+export declare type ProxyChannelProps = {
+    name: string;
+};

package/dist/types/proxyService.d.ts

@@ -0,0 +1,11 @@
+import AbstractChannelProtocol from '../protocol/AbstractChannelProtocol';
+export declare type IService = any;
+export declare type ServiceHandlerPath = string;
+export declare type ProxyRPCClientChannel = AbstractChannelProtocol | {
+    (): AbstractChannelProtocol;
+};
+export declare type ProxyRPCClientProps = {
+    requestPath: string;
+    channel: ProxyRPCClientChannel;
+};
+export declare type ServiceHandlers = Record<string, (...args: any[]) => any>;

package/dist/types/rpc.d.ts

@@ -0,0 +1,25 @@
+export declare enum RequestType {
+    PromiseRequest = "pr",
+    PromiseAbort = "pa",
+    SignalRequest = "sr",
+    SignalAbort = "sa"
+}
+export declare type RequestRawSequenceId = number;
+export declare type RequestSequenceId = string;
+export declare type RequestServicePath = string;
+export declare type RequestFnName = string;
+export declare type RequestEntryHeader = [RequestType, RequestSequenceId, RequestServicePath, RequestFnName];
+export declare type RequestEntryBody = any;
+export declare type RequestEntry = [RequestEntryHeader, RequestEntryBody];
+export declare enum ResponseType {
+    ReturnSuccess = "rs",
+    ReturnFail = "rf",
+    PortSuccess = "ps",
+    PortFail = "pf"
+}
+export declare type ResponseEntryHeader = [ResponseType, RequestSequenceId];
+export declare type ResponseEntryBody = any;
+export declare type HostName = string;
+export declare type HostRequestEntryHeader = [RequestType, RequestSequenceId, RequestServicePath, RequestFnName, HostName];
+export declare type HostRequestEntryBody = any;
+export declare type HostRequestEntry = [HostRequestEntryHeader, HostRequestEntryBody];

package/dist/types/rpcProtocol.d.ts

@@ -0,0 +1,22 @@
+export declare type IRPCProtocolServer = {
+    source: any;
+    encoder: null;
+    decoder: null;
+    onRequest: () => {};
+    handleRequest: () => {};
+    sendReply: () => {};
+};
+export declare type IRPCProtocolClient = {
+    source: any;
+    encode: () => {};
+    decode: () => {};
+    sendRequest: () => {};
+    onReply: () => {};
+    handleReply: () => {};
+};
+export declare type IRPCProtocol = {
+    encode: Function;
+    decode: Function;
+    onMessage: Function;
+    send: Function;
+};

package/dist/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const ERROR = "Error";
+export declare const isArray: (arg: any) => arg is any[];
+export declare const isObject: (val: unknown) => val is object;
+export declare const isFunction: (val: unknown) => val is Function;
+export declare const UNDEFINED: any;

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './jsonrpc';
+export * from './constants';

package/dist/utils/jsonrpc.d.ts

@@ -0,0 +1,36 @@
+import { ID, ErrorResponse } from '../error';
+export declare const jsonrpc: "2.0";
+export interface Request {
+    readonly jsonrpc: typeof jsonrpc;
+    readonly id?: ID;
+    readonly method: string;
+    readonly params: readonly unknown[] | object;
+    readonly remoteStack?: string;
+}
+export interface SuccessResponse {
+    readonly jsonrpc: typeof jsonrpc;
+    readonly id?: ID;
+    readonly result: unknown;
+    readonly undef?: boolean;
+}
+export declare type Response = SuccessResponse | ErrorResponse<unknown>;
+export declare type ErrorMapFunction<T = unknown> = (error: unknown, request: Request) => {
+    code: number;
+    message: string;
+    data?: T;
+};
+export interface AsyncCallErrorDetail {
+    readonly stack?: string;
+    readonly type?: string;
+}
+export declare const makeRequest: (id: ID, method: string, params: readonly unknown[] | object, remoteStack?: string) => Request;
+export declare const makeSuccessResponse: (id: ID, result: unknown) => SuccessResponse;
+export declare const makeErrorResponse: <T>(id: ID, code: number, message: string, data?: T) => ErrorResponse<T>;
+export declare const ErrorResponseParseError: <T>(e: unknown, mapper: ErrorMapFunction<T>) => ErrorResponse<T>;
+export declare const ErrorResponseInvalidRequest: (id: ID) => ErrorResponse;
+export declare const ErrorResponseMethodNotFound: (id: ID) => ErrorResponse;
+export declare const ErrorResponseInvalidParams: (id: ID) => ErrorResponse;
+export declare const ErrorResponseInternalError: (id: ID) => ErrorResponse;
+export declare const ErrorResponseMapped: <T>(request: Request, e: unknown, mapper: ErrorMapFunction<T>) => ErrorResponse<T>;
+export declare const defaultErrorMapper: (stack?: string, code?: number) => ErrorMapFunction<AsyncCallErrorDetail>;
+export declare const isJSONRPCObject: (data: any) => data is Request | SuccessResponse | ErrorResponse<unknown>;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@x-oasis/async-call-rpc",
+  "version": "0.1.38",
+  "description": "async-call-rpc function",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "module": "dist/async-call-rpc.esm.js",
+  "files": [
+    "dist",
+    "index.ts",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "tsdx": "^0.14.1",
+    "ws": "^8.19.0"
+  },
+  "dependencies": {
+    "@x-oasis/deferred": "0.1.38",
+    "@x-oasis/disposable": "0.1.38",
+    "@x-oasis/emitter": "0.1.38",
+    "@x-oasis/id": "0.1.38",
+    "@x-oasis/is-ascii": "0.1.38",
+    "@x-oasis/is-promise": "0.1.38"
+  },
+  "scripts": {
+    "build": "tsdx build --tsconfig tsconfig.build.json",
+    "clean": "rimraf ./dist",
+    "test": "vitest",
+    "compile": "tsc -p tsconfig.build.json"
+  }
+}

package/src/buffer/ARCHITECTURE.md

@@ -0,0 +1,298 @@
+# 分层可配置设计说明
+
+## 什么是"分层可配置设计"？
+
+"分层可配置设计"指的是将系统按照**职责分离**成不同的层次，每一层都可以**独立配置和替换**，而不影响其他层。
+
+## 架构层次图
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    应用层 (Application)                  │
+│  - 业务逻辑代码                                          │
+│  - 调用 RPC 方法                                         │
+└─────────────────────────────────────────────────────────┘
+                        ↓
+┌─────────────────────────────────────────────────────────┐
+│                  RPC 协议层 (Protocol Layer)              │
+│  - AbstractChannelProtocol                               │
+│  - WebSocketChannel / MessageChannel / WorkerChannel    │
+│  - 负责消息路由、请求管理                                 │
+└─────────────────────────────────────────────────────────┘
+                        ↓
+┌─────────────────────────────────────────────────────────┐
+│                中间件层 (Middleware Layer)                │
+│  - serialize / deserialize                               │
+│  - handleRequest / handleResponse                        │
+│  - 可插拔的中间件链                                       │
+└─────────────────────────────────────────────────────────┘
+                        ↓
+┌─────────────────────────────────────────────────────────┐
+│           序列化抽象层 (Serialization Abstraction)       │
+│  - ReadBaseBuffer / WriteBaseBuffer (抽象接口)           │
+│  - 定义统一的 encode/decode 接口                          │
+└─────────────────────────────────────────────────────────┘
+                        ↓
+┌─────────────────────────────────────────────────────────┐
+│         序列化实现层 (Serialization Implementation)      │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
+│  │   JSON       │  │ MessagePack  │  │   CBOR       │ │
+│  │ ReadBuffer   │  │ ReadBuffer   │  │ ReadBuffer   │ │
+│  │ WriteBuffer  │  │ WriteBuffer  │  │ WriteBuffer  │ │
+│  └──────────────┘  └──────────────┘  └──────────────┘ │
+│                                                          │
+│  - 多种序列化格式的具体实现                               │
+│  - 可以随时添加新的实现                                   │
+└─────────────────────────────────────────────────────────┘
+                        ↓
+┌─────────────────────────────────────────────────────────┐
+│              工厂层 (Factory Layer)                       │
+│  - BufferFactory                                         │
+│  - 格式注册表 (Registry)                                  │
+│  - 根据配置创建对应的序列化器                             │
+└─────────────────────────────────────────────────────────┘
+```
+
+## 核心概念
+
+### 1. **分层 (Layered)**
+
+每一层只关注自己的职责：
+
+- **应用层**: 只管调用 RPC，不关心序列化细节
+- **协议层**: 只管消息传输，不关心数据格式
+- **中间件层**: 只管数据转换流程，不关心具体序列化算法
+- **抽象层**: 定义接口契约，不关心具体实现
+- **实现层**: 只管序列化算法，不关心上层如何使用
+- **工厂层**: 只管创建和注册，不关心具体实现
+
+### 2. **可配置 (Configurable)**
+
+每一层都可以通过配置来改变行为：
+
+```typescript
+// 配置方式 1: 在 Channel 中配置
+class MyChannel extends AbstractChannelProtocol {
+  get readBuffer() {
+    // 可以配置为 JSON
+    return BufferFactory.createReadBuffer(SerializationFormat.JSON);
+    // 或者配置为 MessagePack
+    // return BufferFactory.createReadBuffer(SerializationFormat.MESSAGEPACK);
+  }
+}
+
+// 配置方式 2: 通过工厂注册自定义实现
+BufferFactory.registerReadBuffer('my-format', () => new MyCustomBuffer());
+
+// 配置方式 3: 运行时动态切换
+const format = getFormatFromConfig(); // 从配置文件读取
+const buffer = BufferFactory.createReadBuffer(format);
+```
+
+## 设计优势
+
+### ✅ 1. **解耦 (Decoupling)**
+
+各层之间通过接口通信，互不依赖：
+
+```typescript
+// 中间件层不需要知道具体是 JSON 还是 MessagePack
+export const serialize = (channel: AbstractChannelProtocol) => {
+  const fn = (value: SenderMiddlewareOutput) => ({
+    ...value,
+    // 只调用抽象接口，不关心具体实现
+    data: channel.writeBuffer.encode(value.data),
+  });
+  return fn;
+};
+```
+
+### ✅ 2. **可扩展 (Extensible)**
+
+添加新格式不需要修改现有代码：
+
+```typescript
+// 添加新的序列化格式，只需要：
+// 1. 实现 ReadBaseBuffer 和 WriteBaseBuffer
+class MyNewFormatBuffer extends ReadBaseBuffer {
+  decode(data: any): any { /* ... */ }
+  getFormat(): string { return 'my-format'; }
+}
+
+// 2. 注册到工厂
+BufferFactory.registerReadBuffer('my-format', () => new MyNewFormatBuffer());
+
+// 3. 使用
+const buffer = BufferFactory.createReadBuffer('my-format');
+// 完成！不需要修改任何其他代码
+```
+
+### ✅ 3. **可替换 (Replaceable)**
+
+可以轻松切换不同的实现：
+
+```typescript
+// 开发环境使用 JSON（便于调试）
+const devBuffer = BufferFactory.createReadBuffer(SerializationFormat.JSON);
+
+// 生产环境使用 MessagePack（性能更好）
+const prodBuffer = BufferFactory.createReadBuffer(SerializationFormat.MESSAGEPACK);
+
+// 根据环境变量切换
+const buffer = process.env.NODE_ENV === 'production' 
+  ? prodBuffer 
+  : devBuffer;
+```
+
+### ✅ 4. **可测试 (Testable)**
+
+每一层都可以独立测试：
+
+```typescript
+// 测试序列化实现层
+describe('MessagePackBuffer', () => {
+  it('should encode and decode correctly', () => {
+    const buffer = new MessagePackWriteBuffer();
+    const data = { name: 'test', value: 123 };
+    const encoded = buffer.encode(data);
+    const decoded = new MessagePackReadBuffer().decode(encoded);
+    expect(decoded).toEqual(data);
+  });
+});
+
+// 测试工厂层
+describe('BufferFactory', () => {
+  it('should create correct buffer type', () => {
+    const buffer = BufferFactory.createReadBuffer(SerializationFormat.JSON);
+    expect(buffer).toBeInstanceOf(ReadBuffer);
+  });
+});
+```
+
+## 实际应用场景
+
+### 场景 1: 开发 vs 生产环境
+
+```typescript
+// 开发环境：使用 JSON，方便调试
+if (process.env.NODE_ENV === 'development') {
+  channel.readBuffer = BufferFactory.createReadBuffer(SerializationFormat.JSON);
+  channel.writeBuffer = BufferFactory.createWriteBuffer(SerializationFormat.JSON);
+} else {
+  // 生产环境：使用 MessagePack，提升性能
+  channel.readBuffer = BufferFactory.createReadBuffer(SerializationFormat.MESSAGEPACK);
+  channel.writeBuffer = BufferFactory.createWriteBuffer(SerializationFormat.MESSAGEPACK);
+}
+```
+
+### 场景 2: 根据数据大小选择格式
+
+```typescript
+function getOptimalFormat(dataSize: number): SerializationFormat {
+  if (dataSize < 1024) {
+    // 小数据：用 JSON，开销小
+    return SerializationFormat.JSON;
+  } else if (dataSize < 1024 * 1024) {
+    // 中等数据：用 MessagePack，平衡性能和体积
+    return SerializationFormat.MESSAGEPACK;
+  } else {
+    // 大数据：用 Protobuf，极致性能
+    return SerializationFormat.PROTOBUF;
+  }
+}
+```
+
+### 场景 3: 客户端-服务端协商
+
+```typescript
+// 客户端发送支持的格式列表
+const clientFormats = [
+  SerializationFormat.MESSAGEPACK,
+  SerializationFormat.JSON
+];
+
+// 服务端选择最佳格式
+const serverFormats = [
+  SerializationFormat.MESSAGEPACK,
+  SerializationFormat.CBOR,
+  SerializationFormat.JSON
+];
+
+// 协商结果
+const selectedFormat = negotiateFormat(clientFormats, serverFormats);
+// 返回: 'msgpack' (双方都支持的第一个格式)
+
+// 使用协商后的格式
+channel.readBuffer = BufferFactory.createReadBuffer(selectedFormat);
+channel.writeBuffer = BufferFactory.createWriteBuffer(selectedFormat);
+```
+
+## 对比：非分层设计的问题
+
+### ❌ 不好的设计（紧耦合）
+
+```typescript
+// 所有层都直接依赖 JSON
+class Channel {
+  send(data: any) {
+    const json = JSON.stringify(data); // 硬编码 JSON
+    this.socket.send(json);
+  }
+  
+  receive(json: string) {
+    const data = JSON.parse(json); // 硬编码 JSON
+    return data;
+  }
+}
+
+// 问题：
+// 1. 想换成 MessagePack？需要修改所有地方
+// 2. 想支持多种格式？需要大量 if-else
+// 3. 无法测试序列化逻辑（和传输逻辑耦合）
+```
+
+### ✅ 好的设计（分层可配置）
+
+```typescript
+// 抽象层定义接口
+abstract class WriteBaseBuffer {
+  abstract encode(data: any): any;
+}
+
+// 实现层提供具体实现
+class JSONBuffer extends WriteBaseBuffer {
+  encode(data: any) { return JSON.stringify(data); }
+}
+
+class MessagePackBuffer extends WriteBaseBuffer {
+  encode(data: any) { return msgpack.encode(data); }
+}
+
+// 协议层使用抽象接口
+class Channel {
+  constructor(private writeBuffer: WriteBaseBuffer) {}
+  
+  send(data: any) {
+    const encoded = this.writeBuffer.encode(data); // 使用抽象接口
+    this.socket.send(encoded);
+  }
+}
+
+// 使用：可以轻松切换
+const jsonChannel = new Channel(new JSONBuffer());
+const msgpackChannel = new Channel(new MessagePackBuffer());
+```
+
+## 总结
+
+**分层可配置设计** = **职责分离** + **接口抽象** + **工厂模式**
+
+- **分层**: 将复杂系统拆分成多个职责清晰的层次
+- **可配置**: 每一层都可以通过配置来改变行为，而不影响其他层
+- **优势**: 解耦、可扩展、可替换、可测试
+
+这样的设计让你可以：
+- ✅ 轻松添加新的序列化格式
+- ✅ 根据场景选择最合适的格式
+- ✅ 在不影响其他代码的情况下切换格式
+- ✅ 独立测试每一层的功能