@litert/televoke 1.2.0 → 1.3.1

package/src/lib/shared/Channel.impl.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 /**
  * Copyright 2025 Angus.Fenying <fenying@litert.org>
  *
@@ -26,10 +27,15 @@ export interface IChannelEvents extends Shared.IDefaultEvents {
     close(): void;
 
     ['api_call'](
-        callback: (response: v2.IDataChunkField | E.TelevokeError | E.TvErrorResponse) => void,
+        callback: (
+            result: string | Buffer | Array<string | Buffer> | E.TelevokeError | E.TvErrorResponse,
+            binChunks?: Array<Buffer | Buffer[]>,
+        ) => void,
         name: string,
         args: Buffer[],
         sequence: number,
+        argsEncoding: number,
+        extBinChunks?: Buffer[][],
     ): void;
 
     ['push_message'](
@@ -290,7 +296,7 @@ export abstract class AbstractTvChannelV2
         request.callback(packet);
     }
 
-    private _reply(packet: v2.ICommandPacket): void {
+    private _reply<T extends v2.ICommandPacket = v2.ICommandPacket>(packet: T): void {
 
         try {
 
@@ -403,30 +409,44 @@ export abstract class AbstractTvChannelV2
 
                 this.emit(
                     'api_call',
-                    once((response: v2.IDataChunkField | E.TelevokeError) => {
+                    once((response: v2.IEncBinItem | E.TelevokeError, binChunks?: v2.IEncBinItem[]) => {
 
                         this._recvRequests--;
 
-                        this._reply({
-                            'cmd': v2.ECommand.API_CALL,
-                            'typ': response instanceof E.TelevokeError ?
-                                v2.EPacketType.ERROR_RESPONSE :
-                                v2.EPacketType.SUCCESS_RESPONSE,
-                            'seq': packet.seq,
-                            'ct': response,
-                        });
+                        if (response instanceof E.TelevokeError) {
+
+                            this._reply<v2.IErrorReplyPacket>({
+                                'cmd': v2.ECommand.API_CALL,
+                                'typ': v2.EPacketType.ERROR_RESPONSE,
+                                'seq': packet.seq,
+                                'ct': response,
+                            });
+                        }
+                        else {
+                            this._reply<v2.IApiReplyPacketEncoding>({
+                                'cmd': v2.ECommand.API_CALL,
+                                'typ': v2.EPacketType.SUCCESS_RESPONSE,
+                                'seq': packet.seq,
+                                'ct': {
+                                    'body': response,
+                                    binChunks,
+                                },
+                            });
+                        }
                         this._tryClean();
                     }),
-                    (packet as v2.IApiRequestPacket).ct.name,
-                    (packet as v2.IApiRequestPacket).ct.body,
-                    packet.seq
+                    (packet as v2.IApiRequestPacketDecoded).ct.name,
+                    (packet as v2.IApiRequestPacketDecoded).ct.body,
+                    packet.seq,
+                    (packet as v2.IApiRequestPacketDecoded).ct.bodyEnc,
+                    (packet as v2.IApiRequestPacketDecoded).ct.binChunks,
                 );
 
                 break;
 
             case v2.ECommand.BINARY_CHUNK: {
 
-                const stream = this.streams.get((packet as v2.IBinaryChunkRequestPacket).ct.streamId)!;
+                const stream = this.streams.get((packet as v2.IBinaryChunkRequestPacketEncoding).ct.streamId)!;
 
                 if (!stream) {
 
@@ -435,16 +455,16 @@ export abstract class AbstractTvChannelV2
                         'typ': v2.EPacketType.ERROR_RESPONSE,
                         'seq': packet.seq,
                         'ct': new E.errors.stream_not_found({
-                            'sid': (packet as v2.IBinaryChunkRequestPacket).ct.streamId,
+                            'sid': (packet as v2.IBinaryChunkRequestPacketEncoding).ct.streamId,
                             'chId': this.id,
                         }),
                     });
                     break;
                 }
 
-                const chunkSegments = (packet as v2.IBinaryChunkRequestPacket).ct.body as Buffer[];
+                const chunkSegments = (packet as v2.IBinaryChunkRequestPacketEncoding).ct.body as Buffer[];
 
-                const chunkIndex = (packet as v2.IBinaryChunkRequestPacket).ct.index;
+                const chunkIndex = (packet as v2.IBinaryChunkRequestPacketEncoding).ct.index;
 
                 if (chunkIndex === 0xFFFFFFFF) {
 
@@ -457,7 +477,7 @@ export abstract class AbstractTvChannelV2
                         'typ': v2.EPacketType.ERROR_RESPONSE,
                         'seq': packet.seq,
                         'ct': new E.errors.stream_index_mismatch({
-                            'sid': (packet as v2.IBinaryChunkRequestPacket).ct.streamId,
+                            'sid': (packet as v2.IBinaryChunkRequestPacketEncoding).ct.streamId,
                             'chId': this.id,
                         }),
                     });
@@ -541,7 +561,7 @@ export abstract class AbstractTvChannelV2
             'typ': v2.EPacketType.REQUEST,
             'seq': seq,
             'ct': message,
-        } satisfies v2.IPingRequestPacket));
+        } satisfies v2.IPingRequestPacketEncoding));
 
         return new Promise((resolve, reject) => {
 
@@ -584,7 +604,7 @@ export abstract class AbstractTvChannelV2
                 'index': index === false ? 0xFFFFFFFF : index,
                 'body': chunk ?? [],
             }
-        } satisfies v2.IBinaryChunkRequestPacket));
+        } satisfies v2.IBinaryChunkRequestPacketEncoding));
 
         return new Promise((resolve, reject) => {
 
@@ -616,7 +636,7 @@ export abstract class AbstractTvChannelV2
             'typ': v2.EPacketType.REQUEST,
             'seq': seq,
             'ct': message,
-        } satisfies v2.IPushMessageRequestPacket));
+        } satisfies v2.IPushMessageRequestPacketEncoding));
 
         return new Promise((resolve, reject) => {
 

package/src/lib/shared/Encodings/v2/Constants.v2.ts

@@ -28,4 +28,23 @@ export enum EPacketType {
     ERROR_RESPONSE = 0x02,
 }
 
+export const JSON_API_ARGS_ENCODING = 0x00; // JSON encoding
+export const DEFAULT_API_ARGS_ENCODING = JSON_API_ARGS_ENCODING;
+
 export const HEADER_SIZE = 8;
+
+export const API_CALL_REQ_EXT_HEADER_SIZE = 12;
+export const API_CALL_RESP_EXT_HEADER_SIZE = 8;
+
+export enum EApiCallReqExtHeaderFieldOffset {
+
+    LENGTH = 0,
+    BODY_ENC = 4,
+    BIN_CHUNK_QTY = 8
+}
+
+export enum EApiCallRespExtHeaderFieldOffset {
+
+    LENGTH = 0,
+    BIN_CHUNK_QTY = 4
+}

package/src/lib/shared/Encodings/v2/DecoderV2.ts

@@ -36,6 +36,8 @@ interface IDecodeContext {
 
 const B8 = Buffer.allocUnsafe(8);
 const B4 = Buffer.allocUnsafe(4);
+const B_API_CALL_REQ_EXT_HEADER = Buffer.allocUnsafe(CSv2.API_CALL_REQ_EXT_HEADER_SIZE);
+const B_API_CALL_RESP_EXT_HEADER = Buffer.allocUnsafe(CSv2.API_CALL_RESP_EXT_HEADER_SIZE);
 const B2 = Buffer.allocUnsafe(2);
 
 interface IPacketDecoder {
@@ -43,6 +45,45 @@ interface IPacketDecoder {
     decode(ctx: IDecodeContext): dEnc2.ICommandPacket;
 }
 
+function skipBytes(bytes: number, ctx: IDecodeContext): void {
+
+    let readBytes = 0;
+
+    while (readBytes < bytes) {
+
+        if (ctx.chIndex === ctx.chunks.length) {
+
+            throw new errors.incomplete_packet();
+        }
+
+        const c = ctx.chunks[ctx.chIndex];
+        const cLen = c.byteLength;
+        let cOff = ctx.chOffset;
+
+        do {
+
+            readBytes++;
+            cOff++;
+        }
+        while (cOff < cLen && readBytes < bytes);
+
+        if (cOff === cLen) {
+
+            ctx.chIndex++;
+            ctx.chOffset = 0;
+        }
+        else {
+
+            ctx.chOffset = cOff;
+        }
+
+        if (readBytes === bytes) {
+
+            break;
+        }
+    }
+}
+
 function readSmallBytes(bytes: number, buf: Buffer, ctx: IDecodeContext): Buffer {
 
     let readBytes = 0;
@@ -209,25 +250,67 @@ class TvErrorResponseDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.ERROR_RESPONSE,
             'seq': ctx.seq,
             'ct': err,
-        } satisfies dEnc2.IErrorResponsePacket;
+        } satisfies dEnc2.IErrorReplyPacket;
     }
 }
 
 class TvApiRequestDecoder implements IPacketDecoder {
 
+    private _decodeExtPart(
+        ctx: IDecodeContext,
+        ctOut: dEnc2.IApiRequestPacketDecoded['ct']
+    ): dEnc2.IApiRequestPacketDecoded['ct'] {
+
+        if (ctx.chIndex >= ctx.chunks.length) {
+
+            ctOut.bodyEnc = CSv2.DEFAULT_API_ARGS_ENCODING;
+            return ctOut;
+        }
+
+        const hdrBuf = readSmallBytes(B_API_CALL_REQ_EXT_HEADER.byteLength, B_API_CALL_REQ_EXT_HEADER, ctx);
+        const hdrLen = hdrBuf.readUInt32LE(CSv2.EApiCallReqExtHeaderFieldOffset.LENGTH);
+        const bodyEnc = hdrBuf.readUInt32LE(CSv2.EApiCallReqExtHeaderFieldOffset.BODY_ENC);
+        const chkQty = hdrBuf.readUInt32LE(CSv2.EApiCallReqExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!chkQty) {
+
+            ctOut.bodyEnc = bodyEnc;
+            return ctOut;
+        }
+
+        if (hdrLen > B_API_CALL_REQ_EXT_HEADER.length) {
+
+            skipBytes(hdrLen - B_API_CALL_REQ_EXT_HEADER.length, ctx);
+        }
+
+        const binChunks: Buffer[][] = [];
+
+        for (let i = 0; i < chkQty; ++i) {
+
+            binChunks.push(readVarBuffer(ctx));
+        }
+
+        ctOut.bodyEnc = bodyEnc;
+        ctOut.binChunks = binChunks;
+
+        return ctOut;
+    }
+
     public decode(ctx: IDecodeContext): dEnc2.ICommandPacket {
 
         const name = readVarString(ctx);
 
+        const body = readVarBuffer(ctx);
+
         return {
             'cmd': CSv2.ECommand.API_CALL,
             'typ': CSv2.EPacketType.REQUEST,
             'seq': ctx.seq,
-            'ct': {
+            'ct': this._decodeExtPart(ctx, {
                 'name': name,
-                'body': readVarBuffer(ctx),
-            }
-        } satisfies dEnc2.IApiRequestPacket;
+                'body': body,
+            })
+        } satisfies dEnc2.IApiRequestPacketDecoded;
     }
 }
 
@@ -240,7 +323,7 @@ class TvPingRequestDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.REQUEST,
             'seq': ctx.seq,
             'ct': readVarBuffer16(ctx)
-        } satisfies dEnc2.IPingRequestPacket;
+        } satisfies dEnc2.IPingRequestPacketDecoded;
     }
 }
 
@@ -253,7 +336,7 @@ class TvPushMessageRequestDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.REQUEST,
             'seq': ctx.seq,
             'ct': readVarBuffer(ctx)
-        } satisfies dEnc2.IPushMessageRequestPacket;
+        } satisfies dEnc2.IPushMessageRequestPacketDecoded;
     }
 }
 
@@ -272,7 +355,7 @@ class TvBinaryChunkRequestDecoder implements IPacketDecoder {
                 'index': chunkIndex,
                 'body': readVarBuffer(ctx),
             }
-        } satisfies dEnc2.IBinaryChunkRequestPacket;
+        } satisfies dEnc2.IBinaryChunkRequestPacketDecoded;
     }
 }
 
@@ -298,20 +381,59 @@ class TvVoidResponseDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.SUCCESS_RESPONSE,
             'seq': ctx.seq,
             'ct': null
-        } satisfies dEnc2.ISuccessResponsePacket;
+        } satisfies dEnc2.IOkReplyPacket;
     }
 }
 
-class TvApiResponseDecoder implements IPacketDecoder {
+class TvApiReplyDecoder implements IPacketDecoder {
+
+    private _decodeExtPart(
+        ctx: IDecodeContext,
+        ctOut: dEnc2.IApiReplyPacketDecoded['ct'],
+
+    ): dEnc2.IApiReplyPacketDecoded['ct'] {
+
+        if (ctx.chIndex >= ctx.chunks.length) {
+
+            return ctOut;
+        }
+
+        const MIN_EXT_HEADER_LEN = CSv2.API_CALL_RESP_EXT_HEADER_SIZE;
+        const extHdr = readSmallBytes(MIN_EXT_HEADER_LEN, B_API_CALL_RESP_EXT_HEADER, ctx);
+        const extHdrLen = extHdr.readUInt32LE(CSv2.EApiCallRespExtHeaderFieldOffset.LENGTH);
+        const extBinChunkQty = extHdr.readUInt32LE(CSv2.EApiCallRespExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!extBinChunkQty) {
+
+            return ctOut;
+        }
+
+        if (extHdrLen > MIN_EXT_HEADER_LEN) {
+
+            skipBytes(extHdrLen - MIN_EXT_HEADER_LEN, ctx);
+        }
+
+        const extBinChunks: Buffer[][] = [];
+
+        for (let i = 0; i < extBinChunkQty; ++i) {
+
+            extBinChunks.push(readVarBuffer(ctx));
+        }
+
+        ctOut.binChunks = extBinChunks;
+
+        return ctOut;
+    }
 
     public decode(ctx: IDecodeContext): dEnc2.ICommandPacket {
 
+        const body = readVarBuffer(ctx);
         return {
             'cmd': CSv2.ECommand.API_CALL,
             'typ': CSv2.EPacketType.SUCCESS_RESPONSE,
             'seq': ctx.seq,
-            'ct': readVarBuffer(ctx)
-        } satisfies dEnc2.IApiResponsePacket;
+            'ct': this._decodeExtPart(ctx, { body })
+        } satisfies dEnc2.IApiReplyPacketDecoded;
     }
 }
 
@@ -324,7 +446,7 @@ class TvPingResponseDecoder implements IPacketDecoder {
             'typ': CSv2.EPacketType.SUCCESS_RESPONSE,
             'seq': ctx.seq,
             'ct': readVarBuffer16(ctx)
-        } satisfies dEnc2.IPingResponsePacket;
+        } satisfies dEnc2.IPingReplyPacketDecoded;
     }
 }
 
@@ -345,7 +467,7 @@ const packetDecoders: Record<number, IPacketDecoder> = {
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.PUSH_MESSAGE]: new TvVoidResponseDecoder(),
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.CLOSE]: new TvVoidResponseDecoder(),
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.BINARY_CHUNK]: new TvVoidResponseDecoder(),
-    [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.API_CALL]: new TvApiResponseDecoder(),
+    [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.API_CALL]: new TvApiReplyDecoder(),
     [CSv2.EPacketType.SUCCESS_RESPONSE + 0x100 * CSv2.ECommand.PING]: new TvPingResponseDecoder(),
 };
 

package/src/lib/shared/Encodings/v2/EncoderV2.ts

@@ -37,9 +37,10 @@ interface IPacketEncoder {
      */
     encode(packet: dEnc2.ICommandPacket): Array<string | Buffer>;
 }
-class ErrorResponseEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IErrorResponsePacket): v2.IDataChunkArray {
+class ErrorReplyEncoder implements IPacketEncoder {
+
+    public encode(packet: dEnc2.IErrorReplyPacket): v2.IBinLikeArray {
 
         const errorMsg = `${packet.ct.name}:${packet.ct.message}`;
 
@@ -56,9 +57,9 @@ class ErrorResponseEncoder implements IPacketEncoder {
     }
 }
 
-class VoidResponseEncoder implements IPacketEncoder {
+class VoidReplyEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.ISuccessResponsePacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IOkReplyPacket): v2.IBinLikeArray {
 
         const buf = Buffer.allocUnsafe(CS.HEADER_SIZE);
 
@@ -70,13 +71,68 @@ class VoidResponseEncoder implements IPacketEncoder {
 
 class ApiRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IApiRequestPacket): v2.IDataChunkArray {
+    private _createExtPart(
+        out: dEnc2.IBinLikeArray,
+        argsBodyEncoding: number = CS.DEFAULT_API_ARGS_ENCODING,
+        binChunks?: dEnc2.IEncBinItem[],
+    ): dEnc2.IBinLikeArray {
+
+        const header = Buffer.allocUnsafe(CS.API_CALL_REQ_EXT_HEADER_SIZE);
+
+        out.push(header);
+
+        header.writeUInt32LE(CS.API_CALL_REQ_EXT_HEADER_SIZE, CS.EApiCallReqExtHeaderFieldOffset.LENGTH);
+        header.writeUInt32LE(argsBodyEncoding, CS.EApiCallReqExtHeaderFieldOffset.BODY_ENC);
+        header.writeUInt32LE(binChunks?.length ?? 0, CS.EApiCallReqExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!binChunks?.length) {
+
+            return out;
+        }
+
+        for (const chunk of binChunks) {
+
+            let chunkLen = 0;
+
+            if (!chunk.length) {
+
+                const lenBuf = Buffer.allocUnsafe(4);
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                continue;
+            }
+
+            const lenBuf = Buffer.allocUnsafe(4);
+
+            if (Array.isArray(chunk)) {
+
+                for (const p of chunk) {
+
+                    chunkLen += p instanceof Buffer ? p.length : Buffer.byteLength(p);
+                }
+
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                out.push(...chunk);
+            }
+            else {
+
+                lenBuf.writeUInt32LE(Buffer.byteLength(chunk), 0);
+                out.push(lenBuf, chunk);
+            }
+        }
+
+        return out;
+    }
+
+    public encode(packet: dEnc2.IApiRequestPacketEncoding): v2.IBinLikeArray {
 
         const apiNameLen = Buffer.byteLength(packet.ct.name);
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2 + 4 + apiNameLen);
 
         writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
+
         leadSeg.writeUInt16LE(apiNameLen, CS.HEADER_SIZE);
         leadSeg.write(packet.ct.name, CS.HEADER_SIZE + 2);
 
@@ -91,18 +147,24 @@ class ApiRequestEncoder implements IPacketEncoder {
 
             leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE + 2 + apiNameLen);
 
-            return [leadSeg, ...packet.ct.body];
+            return this._createExtPart([
+                leadSeg,
+                ...packet.ct.body
+            ], packet.ct.bodyEnc, packet.ct.binChunks);
         }
 
         leadSeg.writeUInt32LE(Buffer.byteLength(packet.ct.body), CS.HEADER_SIZE + 2 + apiNameLen);
 
-        return [leadSeg, packet.ct.body];
+        return this._createExtPart([
+            leadSeg,
+            packet.ct.body
+        ], packet.ct.bodyEnc, packet.ct.binChunks);
     }
 }
 
 class BinaryChunkRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IBinaryChunkRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IBinaryChunkRequestPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 12);
 
@@ -132,7 +194,7 @@ class BinaryChunkRequestEncoder implements IPacketEncoder {
 
 class PingRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IPingRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IPingRequestPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2);
 
@@ -160,7 +222,7 @@ class PingRequestEncoder implements IPacketEncoder {
 
 class CloseRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.ICloseRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.ICloseRequestPacket): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE);
 
@@ -172,7 +234,7 @@ class CloseRequestEncoder implements IPacketEncoder {
 
 class PushMessageRequestEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IPushMessageRequestPacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IPushMessageRequestPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 4);
 
@@ -198,37 +260,99 @@ class PushMessageRequestEncoder implements IPacketEncoder {
     }
 }
 
-class ApiResponseEncoder implements IPacketEncoder {
+class ApiReplyEncoder implements IPacketEncoder {
+
+    private _createExtPart(
+        out: dEnc2.IBinLikeArray,
+        binChunks?: dEnc2.IEncBinItem[],
+    ): dEnc2.IBinLikeArray {
+
+        const header = Buffer.allocUnsafe(CS.API_CALL_RESP_EXT_HEADER_SIZE);
+        out.push(header);
+
+        header.writeUInt32LE(CS.API_CALL_RESP_EXT_HEADER_SIZE, CS.EApiCallRespExtHeaderFieldOffset.LENGTH);
+        header.writeUInt32LE(binChunks?.length ?? 0, CS.EApiCallRespExtHeaderFieldOffset.BIN_CHUNK_QTY);
+
+        if (!binChunks?.length) {
+
+            return out;
+        }
+
+        for (const chunk of binChunks) {
+
+            let chunkLen = 0;
+
+            if (!chunk.length) {
+
+                const lenBuf = Buffer.allocUnsafe(4);
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                continue;
+            }
 
-    public encode(packet: dEnc2.IApiResponsePacket): v2.IDataChunkArray {
+            const lenBuf = Buffer.allocUnsafe(4);
+
+            if (Array.isArray(chunk)) {
+
+                for (const p of chunk) {
+
+                    chunkLen += p instanceof Buffer ? p.length : Buffer.byteLength(p);
+                }
+
+                lenBuf.writeUInt32LE(chunkLen, 0);
+                out.push(lenBuf);
+                out.push(...chunk);
+            }
+            else {
+
+                lenBuf.writeUInt32LE(Buffer.byteLength(chunk), 0);
+                out.push(lenBuf, chunk);
+            }
+        }
+
+        return out;
+    }
+
+    public encode(packet: dEnc2.IApiReplyPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 4);
 
         writePacketHeader(leadSeg, packet.cmd, packet.typ, packet.seq);
 
-        if (Array.isArray(packet.ct)) {
+        let bodyLen = 0;
 
-            let bodyLen = 0;
+        if (Array.isArray(packet.ct.body)) {
 
-            for (const p of packet.ct) {
+            for (const p of packet.ct.body) {
 
-                bodyLen += Buffer.byteLength(p);
+                bodyLen += p instanceof Buffer ? p.byteLength : Buffer.byteLength(p);
             }
+        }
+        else {
 
-            leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE);
+            bodyLen = packet.ct.body instanceof Buffer ? packet.ct.body.byteLength : Buffer.byteLength(packet.ct.body);
+        }
 
-            return [leadSeg, ...packet.ct];
+        leadSeg.writeUInt32LE(bodyLen, CS.HEADER_SIZE);
+
+        const ret: v2.IBinLikeArray = [leadSeg];
+
+        if (Array.isArray(packet.ct.body)) {
+
+            ret.push(...packet.ct.body);
         }
+        else {
 
-        leadSeg.writeUInt32LE(Buffer.byteLength(packet.ct), CS.HEADER_SIZE);
+            ret.push(packet.ct.body);
+        }
 
-        return [leadSeg, packet.ct];
+        return this._createExtPart(ret, packet.ct.binChunks);
     }
 }
 
-class PingResponseEncoder implements IPacketEncoder {
+class PingReplyEncoder implements IPacketEncoder {
 
-    public encode(packet: dEnc2.IPingResponsePacket): v2.IDataChunkArray {
+    public encode(packet: dEnc2.IPingReplyPacketEncoding): v2.IBinLikeArray {
 
         const leadSeg = Buffer.allocUnsafe(CS.HEADER_SIZE + 2);
 
@@ -262,22 +386,22 @@ const encoders: Record<number, IPacketEncoder> = {
     [CS.EPacketType.REQUEST * 0x100 + CS.ECommand.PING]: new PingRequestEncoder(),
     [CS.EPacketType.REQUEST * 0x100 + CS.ECommand.PUSH_MESSAGE]: new PushMessageRequestEncoder(),
 
-    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ApiResponseEncoder(),
-    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new VoidResponseEncoder(),
-    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new VoidResponseEncoder(),
-    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PING]: new PingResponseEncoder(),
-    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new VoidResponseEncoder(),
-
-    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ErrorResponseEncoder(),
-    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new ErrorResponseEncoder(),
-    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new ErrorResponseEncoder(),
-    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PING]: new ErrorResponseEncoder(),
-    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new ErrorResponseEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ApiReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new VoidReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new VoidReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PING]: new PingReplyEncoder(),
+    [CS.EPacketType.SUCCESS_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new VoidReplyEncoder(),
+
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.API_CALL]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.BINARY_CHUNK]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.CLOSE]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PING]: new ErrorReplyEncoder(),
+    [CS.EPacketType.ERROR_RESPONSE * 0x100 + CS.ECommand.PUSH_MESSAGE]: new ErrorReplyEncoder(),
 };
 
 export class TvEncoderV2 {
 
-    public encode(packet: dEnc2.ICommandPacket): Array<Buffer | string> {
+    public encode(packet: dEnc2.ICommandPacket): v2.IBinLikeArray {
 
         return encoders[packet.typ * 0x100 + packet.cmd].encode(packet);
     }