deukpack 1.0.0

package/dist/protocols/WireProtocol.js

@@ -0,0 +1,912 @@
+"use strict";
+/**
+ * DeukPack Wire Protocol
+ * DpProtocol interface and implementations.
+ * - DpBinaryProtocol, DpCompactProtocol: Apache Thrift wire-compatible (binary/compact).
+ * - DpPackProtocol: DeukPack-native (magic 0x44 0x50 0x01); detectable via detectWireProtocol().
+ * - 엔벨로프(writeEnvelope/readEnvelope): 팩 시 프로토콜 타입 저장 → 언팩 시 타입으로 디코더 선택. 기본(성능·메모리 권장): pack.
+ * - Cross-platform serialization with endian support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DpPackProtocol = exports.DP_WIRE_PROTOCOL_ZEROCOPY = exports.DP_WIRE_PROTOCOL_PACK = exports.DP_WIRE_PROTOCOL_COMPACT = exports.DP_WIRE_PROTOCOL_BINARY = exports.DP_WIRE_ENVELOPE_MAGIC1 = exports.DP_WIRE_ENVELOPE_MAGIC0 = exports.DP_WIRE_ENVELOPE_SIZE = exports.DP_PACK_MAGIC = exports.DpCompactProtocol = exports.DpZeroCopyProtocol = exports.DpBinaryProtocol = exports.DpMessageType = exports.DpWireType = void 0;
+exports.writeEnvelope = writeEnvelope;
+exports.readEnvelope = readEnvelope;
+exports.detectWireProtocol = detectWireProtocol;
+exports.createProtocolForUnpack = createProtocolForUnpack;
+var DpWireType;
+(function (DpWireType) {
+    DpWireType[DpWireType["Stop"] = 0] = "Stop";
+    DpWireType[DpWireType["Void"] = 1] = "Void";
+    DpWireType[DpWireType["Bool"] = 2] = "Bool";
+    DpWireType[DpWireType["Byte"] = 3] = "Byte";
+    DpWireType[DpWireType["Double"] = 4] = "Double";
+    DpWireType[DpWireType["I16"] = 6] = "I16";
+    DpWireType[DpWireType["I32"] = 8] = "I32";
+    DpWireType[DpWireType["I64"] = 10] = "I64";
+    DpWireType[DpWireType["String"] = 11] = "String";
+    DpWireType[DpWireType["Struct"] = 12] = "Struct";
+    DpWireType[DpWireType["Map"] = 13] = "Map";
+    DpWireType[DpWireType["Set"] = 14] = "Set";
+    DpWireType[DpWireType["List"] = 15] = "List";
+})(DpWireType || (exports.DpWireType = DpWireType = {}));
+var DpMessageType;
+(function (DpMessageType) {
+    DpMessageType[DpMessageType["Call"] = 1] = "Call";
+    DpMessageType[DpMessageType["Reply"] = 2] = "Reply";
+    DpMessageType[DpMessageType["Exception"] = 3] = "Exception";
+    DpMessageType[DpMessageType["Oneway"] = 4] = "Oneway";
+})(DpMessageType || (exports.DpMessageType = DpMessageType = {}));
+/**
+ * Thrift-compatible binary protocol (fixed-width fields, type+id per field).
+ * Endianness configurable (default little-endian); Apache Thrift binary is big-endian.
+ */
+class DpBinaryProtocol {
+    constructor(buffer, littleEndian = true) {
+        this.buffer = buffer;
+        this.view = new DataView(buffer);
+        this.offset = 0;
+        this.littleEndian = littleEndian;
+    }
+    // Write methods
+    writeStructBegin(_struct) {
+        // Binary protocol doesn't write struct names
+    }
+    writeStructEnd() {
+        // Binary protocol doesn't write struct end markers
+    }
+    writeFieldBegin(field) {
+        this.writeByte(field.type);
+        this.writeI16(field.id);
+    }
+    writeFieldEnd() {
+        // Binary protocol doesn't write field end markers
+    }
+    writeFieldStop() {
+        this.writeByte(DpWireType.Stop);
+    }
+    writeBool(value) {
+        this.writeByte(value ? 1 : 0);
+    }
+    writeByte(value) {
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    writeI16(value) {
+        this.view.setInt16(this.offset, value, this.littleEndian);
+        this.offset += 2;
+    }
+    writeI32(value) {
+        this.view.setInt32(this.offset, value, this.littleEndian);
+        this.offset += 4;
+    }
+    writeI64(value) {
+        this.view.setBigInt64(this.offset, value, this.littleEndian);
+        this.offset += 8;
+    }
+    writeDouble(value) {
+        this.view.setFloat64(this.offset, value, this.littleEndian);
+        this.offset += 8;
+    }
+    writeString(value) {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(value);
+        this.writeI32(bytes.length);
+        this.writeBinary(new Uint8Array(bytes));
+    }
+    writeBinary(value) {
+        this.writeI32(value.length);
+        new Uint8Array(this.buffer, this.offset, value.length).set(value);
+        this.offset += value.length;
+    }
+    writeListBegin(list) {
+        this.writeByte(list.elementType);
+        this.writeI32(list.count);
+    }
+    writeListEnd() {
+        // Binary protocol doesn't write list end markers
+    }
+    writeSetBegin(set) {
+        this.writeByte(set.elementType);
+        this.writeI32(set.count);
+    }
+    writeSetEnd() {
+        // Binary protocol doesn't write set end markers
+    }
+    writeMapBegin(map) {
+        this.writeByte(map.keyType);
+        this.writeByte(map.valueType);
+        this.writeI32(map.count);
+    }
+    writeMapEnd() {
+        // Binary protocol doesn't write map end markers
+    }
+    // Read methods
+    readStructBegin() {
+        return { name: '' };
+    }
+    readStructEnd() {
+        // Binary protocol doesn't read struct end markers
+    }
+    readFieldBegin() {
+        const type = this.readByte();
+        if (type === DpWireType.Stop) {
+            return { name: '', type: DpWireType.Stop, id: 0 };
+        }
+        const id = this.readI16();
+        return { name: '', type: type, id };
+    }
+    readFieldEnd() {
+        // Binary protocol doesn't read field end markers
+    }
+    readBool() {
+        return this.readByte() !== 0;
+    }
+    readByte() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readI16() {
+        const value = this.view.getInt16(this.offset, this.littleEndian);
+        this.offset += 2;
+        return value;
+    }
+    readI32() {
+        const value = this.view.getInt32(this.offset, this.littleEndian);
+        this.offset += 4;
+        return value;
+    }
+    readI64() {
+        const value = this.view.getBigInt64(this.offset, this.littleEndian);
+        this.offset += 8;
+        return value;
+    }
+    readDouble() {
+        const value = this.view.getFloat64(this.offset, this.littleEndian);
+        this.offset += 8;
+        return value;
+    }
+    readString() {
+        const length = this.readI32();
+        const bytes = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+    readBinary() {
+        const length = this.readI32();
+        const bytes = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        return bytes;
+    }
+    readListBegin() {
+        const elementType = this.readByte();
+        const count = this.readI32();
+        return { elementType: elementType, count };
+    }
+    readListEnd() {
+        // Binary protocol doesn't read list end markers
+    }
+    readSetBegin() {
+        const elementType = this.readByte();
+        const count = this.readI32();
+        return { elementType: elementType, count };
+    }
+    readSetEnd() {
+        // Binary protocol doesn't read set end markers
+    }
+    readMapBegin() {
+        const keyType = this.readByte();
+        const valueType = this.readByte();
+        const count = this.readI32();
+        return { keyType: keyType, valueType: valueType, count };
+    }
+    readMapEnd() {
+        // Binary protocol doesn't read map end markers
+    }
+    // Utility methods
+    getBuffer() {
+        return this.buffer.slice(0, this.offset);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    setOffset(offset) {
+        this.offset = offset;
+    }
+}
+exports.DpBinaryProtocol = DpBinaryProtocol;
+/**
+ * 제로카피 프로토콜 (Zero-Copy Protocol). 기본 선택사항 아님 — 사용자가 writeEnvelope(..., 'zerocopy') 또는 엔벨로프 id 3으로 명시할 때만 사용.
+ * Wire 포맷은 Thrift Binary와 동일. read 시 버퍼 복사 없이 뷰(Uint8Array) 반환.
+ * 주의: 반환된 뷰 사용 중에는 원본 버퍼를 수정하지 말 것. 버퍼 수명이 뷰보다 길어야 함.
+ */
+class DpZeroCopyProtocol {
+    constructor(buffer, littleEndian = true) {
+        this.buffer = buffer;
+        this.view = new DataView(buffer);
+        this.offset = 0;
+        this.littleEndian = littleEndian;
+    }
+    writeStructBegin(_struct) { }
+    writeStructEnd() { }
+    writeFieldBegin(field) {
+        this.writeByte(field.type);
+        this.writeI16(field.id);
+    }
+    writeFieldEnd() { }
+    writeFieldStop() {
+        this.writeByte(DpWireType.Stop);
+    }
+    writeBool(value) {
+        this.writeByte(value ? 1 : 0);
+    }
+    writeByte(value) {
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    writeI16(value) {
+        this.view.setInt16(this.offset, value, this.littleEndian);
+        this.offset += 2;
+    }
+    writeI32(value) {
+        this.view.setInt32(this.offset, value, this.littleEndian);
+        this.offset += 4;
+    }
+    writeI64(value) {
+        this.view.setBigInt64(this.offset, value, this.littleEndian);
+        this.offset += 8;
+    }
+    writeDouble(value) {
+        this.view.setFloat64(this.offset, value, this.littleEndian);
+        this.offset += 8;
+    }
+    writeString(value) {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(value);
+        this.writeI32(bytes.length);
+        this.writeBinary(new Uint8Array(bytes));
+    }
+    writeBinary(value) {
+        this.writeI32(value.length);
+        new Uint8Array(this.buffer, this.offset, value.length).set(value);
+        this.offset += value.length;
+    }
+    writeListBegin(list) {
+        this.writeByte(list.elementType);
+        this.writeI32(list.count);
+    }
+    writeListEnd() { }
+    writeSetBegin(set) {
+        this.writeByte(set.elementType);
+        this.writeI32(set.count);
+    }
+    writeSetEnd() { }
+    writeMapBegin(map) {
+        this.writeByte(map.keyType);
+        this.writeByte(map.valueType);
+        this.writeI32(map.count);
+    }
+    writeMapEnd() { }
+    readStructBegin() {
+        return { name: '' };
+    }
+    readStructEnd() { }
+    readFieldBegin() {
+        const type = this.readByte();
+        if (type === DpWireType.Stop) {
+            return { name: '', type: DpWireType.Stop, id: 0 };
+        }
+        const id = this.readI16();
+        return { name: '', type: type, id };
+    }
+    readFieldEnd() { }
+    readBool() {
+        return this.readByte() !== 0;
+    }
+    readByte() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readI16() {
+        const value = this.view.getInt16(this.offset, this.littleEndian);
+        this.offset += 2;
+        return value;
+    }
+    readI32() {
+        const value = this.view.getInt32(this.offset, this.littleEndian);
+        this.offset += 4;
+        return value;
+    }
+    readI64() {
+        const value = this.view.getBigInt64(this.offset, this.littleEndian);
+        this.offset += 8;
+        return value;
+    }
+    readDouble() {
+        const value = this.view.getFloat64(this.offset, this.littleEndian);
+        this.offset += 8;
+        return value;
+    }
+    readString() {
+        const length = this.readI32();
+        const bytes = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        return new TextDecoder().decode(bytes);
+    }
+    /** 제로카피: 원본 버퍼에 대한 뷰 반환. 버퍼 수명·불변성 책임은 호출자. */
+    readBinary() {
+        const length = this.readI32();
+        const view = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        return view;
+    }
+    readListBegin() {
+        const elementType = this.readByte();
+        const count = this.readI32();
+        return { elementType: elementType, count };
+    }
+    readListEnd() { }
+    readSetBegin() {
+        const elementType = this.readByte();
+        const count = this.readI32();
+        return { elementType: elementType, count };
+    }
+    readSetEnd() { }
+    readMapBegin() {
+        const keyType = this.readByte();
+        const valueType = this.readByte();
+        const count = this.readI32();
+        return { keyType: keyType, valueType: valueType, count };
+    }
+    readMapEnd() { }
+    getBuffer() {
+        return this.buffer.slice(0, this.offset);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    setOffset(offset) {
+        this.offset = offset;
+    }
+}
+exports.DpZeroCopyProtocol = DpZeroCopyProtocol;
+/**
+ * Thrift-compatible compact protocol (varint encoding, smaller payload).
+ * Same wire format family as Apache Thrift compact.
+ */
+class DpCompactProtocol {
+    constructor(buffer, littleEndian = true) {
+        this.buffer = buffer;
+        this.view = new DataView(buffer);
+        this.offset = 0;
+        this.littleEndian = littleEndian;
+    }
+    // Compact protocol uses variable-length encoding
+    writeStructBegin(_struct) {
+        // Compact protocol doesn't write struct names
+    }
+    writeStructEnd() {
+        // Compact protocol doesn't write struct end markers
+    }
+    writeFieldBegin(field) {
+        if (field.type === DpWireType.Stop) {
+            this.writeByte(DpWireType.Stop);
+        }
+        else {
+            this.writeByte((field.id << 4) | field.type);
+        }
+    }
+    writeFieldEnd() {
+        // Compact protocol doesn't write field end markers
+    }
+    writeFieldStop() {
+        this.writeByte(DpWireType.Stop);
+    }
+    writeBool(value) {
+        this.writeByte(value ? 1 : 0);
+    }
+    writeByte(value) {
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    writeI16(value) {
+        this.writeVarint(value);
+    }
+    writeI32(value) {
+        this.writeVarint(value);
+    }
+    writeI64(value) {
+        this.writeVarint64(value);
+    }
+    writeDouble(value) {
+        this.view.setFloat64(this.offset, value, this.littleEndian);
+        this.offset += 8;
+    }
+    writeString(value) {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(value);
+        this.writeVarint(bytes.length);
+        this.writeBinary(new Uint8Array(bytes));
+    }
+    writeBinary(value) {
+        this.writeVarint(value.length);
+        new Uint8Array(this.buffer, this.offset, value.length).set(value);
+        this.offset += value.length;
+    }
+    writeListBegin(list) {
+        this.writeByte((list.elementType << 4) | (list.count < 15 ? list.count : 15));
+        if (list.count >= 15) {
+            this.writeVarint(list.count - 15);
+        }
+    }
+    writeListEnd() {
+        // Compact protocol doesn't write list end markers
+    }
+    writeSetBegin(set) {
+        this.writeListBegin({ elementType: set.elementType, count: set.count });
+    }
+    writeSetEnd() {
+        // Compact protocol doesn't write set end markers
+    }
+    writeMapBegin(map) {
+        this.writeVarint(map.count);
+        if (map.count > 0) {
+            this.writeByte((map.keyType << 4) | map.valueType);
+        }
+    }
+    writeMapEnd() {
+        // Compact protocol doesn't write map end markers
+    }
+    // Read methods (similar to binary protocol but with varint decoding)
+    readStructBegin() {
+        return { name: '' };
+    }
+    readStructEnd() {
+        // Compact protocol doesn't read struct end markers
+    }
+    readFieldBegin() {
+        const byte = this.readByte();
+        if (byte === DpWireType.Stop) {
+            return { name: '', type: DpWireType.Stop, id: 0 };
+        }
+        const type = byte & 0x0F;
+        const id = byte >> 4;
+        return { name: '', type: type, id };
+    }
+    readFieldEnd() {
+        // Compact protocol doesn't read field end markers
+    }
+    readBool() {
+        return this.readByte() !== 0;
+    }
+    readByte() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readI16() {
+        return this.readVarint();
+    }
+    readI32() {
+        return this.readVarint();
+    }
+    readI64() {
+        return this.readVarint64();
+    }
+    readDouble() {
+        const value = this.view.getFloat64(this.offset, this.littleEndian);
+        this.offset += 8;
+        return value;
+    }
+    readString() {
+        const length = this.readVarint();
+        const bytes = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+    readBinary() {
+        const length = this.readVarint();
+        const bytes = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        return bytes;
+    }
+    readListBegin() {
+        const byte = this.readByte();
+        const elementType = byte & 0x0F;
+        let count = byte >> 4;
+        if (count === 15) {
+            count = this.readVarint() + 15;
+        }
+        return { elementType: elementType, count };
+    }
+    readListEnd() {
+        // Compact protocol doesn't read list end markers
+    }
+    readSetBegin() {
+        const list = this.readListBegin();
+        return { elementType: list.elementType, count: list.count };
+    }
+    readSetEnd() {
+        // Compact protocol doesn't read set end markers
+    }
+    readMapBegin() {
+        const count = this.readVarint();
+        if (count === 0) {
+            return { keyType: DpWireType.Stop, valueType: DpWireType.Stop, count: 0 };
+        }
+        const byte = this.readByte();
+        const keyType = byte >> 4;
+        const valueType = byte & 0x0F;
+        return { keyType: keyType, valueType: valueType, count };
+    }
+    readMapEnd() {
+        // Compact protocol doesn't read map end markers
+    }
+    // Varint encoding/decoding
+    writeVarint(value) {
+        while (value > 0x7F) {
+            this.writeByte((value & 0x7F) | 0x80);
+            value >>>= 7;
+        }
+        this.writeByte(value & 0x7F);
+    }
+    readVarint() {
+        let result = 0;
+        let shift = 0;
+        let byte;
+        do {
+            byte = this.readByte();
+            result |= (byte & 0x7F) << shift;
+            shift += 7;
+        } while (byte & 0x80);
+        return result;
+    }
+    writeVarint64(value) {
+        while (value > 0x7fn) {
+            this.writeByte(Number((value & 0x7fn) | 0x80n));
+            value = value >> 7n;
+        }
+        this.writeByte(Number(value & 0x7fn));
+    }
+    readVarint64() {
+        let result = 0n;
+        let shift = 0n;
+        let byte;
+        do {
+            byte = this.readByte();
+            result |= BigInt(byte & 0x7F) << shift;
+            shift += 7n;
+        } while (byte & 0x80);
+        return result;
+    }
+    // Utility methods
+    getBuffer() {
+        return this.buffer.slice(0, this.offset);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    setOffset(offset) {
+        this.offset = offset;
+    }
+}
+exports.DpCompactProtocol = DpCompactProtocol;
+/** Magic header for DpPack wire (3 bytes): 'DP' + version 1. Enables protocol detection from stored bytes. */
+exports.DP_PACK_MAGIC = new Uint8Array([0x44, 0x50, 0x01]);
+const DP_PACK_MAGIC_LEN = 3;
+/** Envelope: [0x44, 0x50, version, protocol_id]. Pack/Unpack 시 저장된 프로토콜 타입으로 올바른 디코더 선택. */
+exports.DP_WIRE_ENVELOPE_SIZE = 4;
+exports.DP_WIRE_ENVELOPE_MAGIC0 = 0x44;
+exports.DP_WIRE_ENVELOPE_MAGIC1 = 0x50;
+/** Protocol id in envelope: 성능·메모리 기본은 pack(2). 제로카피(3)는 사용자 선택 전용(기본 아님), FlatBuffers 유사·버퍼 뷰 반환. */
+exports.DP_WIRE_PROTOCOL_BINARY = 0;
+exports.DP_WIRE_PROTOCOL_COMPACT = 1;
+exports.DP_WIRE_PROTOCOL_PACK = 2;
+exports.DP_WIRE_PROTOCOL_ZEROCOPY = 3;
+const ENVELOPE_PROTOCOL_TO_ID = {
+    binary: exports.DP_WIRE_PROTOCOL_BINARY,
+    compact: exports.DP_WIRE_PROTOCOL_COMPACT,
+    pack: exports.DP_WIRE_PROTOCOL_PACK,
+    zerocopy: exports.DP_WIRE_PROTOCOL_ZEROCOPY
+};
+const ENVELOPE_ID_TO_PROTOCOL = {
+    [exports.DP_WIRE_PROTOCOL_BINARY]: 'binary',
+    [exports.DP_WIRE_PROTOCOL_COMPACT]: 'compact',
+    [exports.DP_WIRE_PROTOCOL_PACK]: 'pack',
+    [exports.DP_WIRE_PROTOCOL_ZEROCOPY]: 'zerocopy'
+};
+/**
+ * Pack 시 버퍼 앞에 프로토콜 타입을 씀. 호출 후 동일 버퍼로 프로토콜 생성하고 setOffset(DP_WIRE_ENVELOPE_SIZE) 후 Write.
+ * @param buffer 최소 4바이트 이상 확보된 버퍼
+ * @param protocol 저장할 프로토콜 (기본·권장: 'pack' — 성능·메모리 양호)
+ * @param version 엔벨로프 버전 (기본 1)
+ */
+function writeEnvelope(buffer, protocol, version = 1) {
+    const u8 = new Uint8Array(buffer, 0, exports.DP_WIRE_ENVELOPE_SIZE);
+    u8[0] = exports.DP_WIRE_ENVELOPE_MAGIC0;
+    u8[1] = exports.DP_WIRE_ENVELOPE_MAGIC1;
+    u8[2] = version & 0xff;
+    u8[3] = ENVELOPE_PROTOCOL_TO_ID[protocol];
+}
+/**
+ * Unpack 시 저장된 프로토콜 타입 반환. 엔벨로프가 있으면 version·protocol 반환; 없으면 null.
+ */
+function readEnvelope(buffer) {
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    if (bytes.length < exports.DP_WIRE_ENVELOPE_SIZE ||
+        bytes[0] !== exports.DP_WIRE_ENVELOPE_MAGIC0 ||
+        bytes[1] !== exports.DP_WIRE_ENVELOPE_MAGIC1) {
+        return null;
+    }
+    const version = (bytes[2] ?? 0) & 0xff;
+    const id = (bytes[3] ?? 0) & 0xff;
+    const protocol = ENVELOPE_ID_TO_PROTOCOL[id];
+    if (protocol === undefined)
+        return null;
+    return { version, protocol };
+}
+/**
+ * DeukPack-native wire protocol (pack).
+ * Same encoding as Thrift compact (varint tag + varint values) but with a 3-byte magic header
+ * so stored payloads can be identified as DpPack. Not wire-compatible with Apache Thrift.
+ */
+class DpPackProtocol {
+    constructor(buffer, littleEndian = true) {
+        this.buffer = buffer;
+        this.view = new DataView(buffer);
+        this.offset = 0;
+        this.littleEndian = littleEndian;
+    }
+    ensureMagicWritten() {
+        if (this.offset === 0) {
+            new Uint8Array(this.buffer).set(exports.DP_PACK_MAGIC, 0);
+            this.offset = DP_PACK_MAGIC_LEN;
+        }
+    }
+    ensureMagicSkipped() {
+        if (this.offset === 0 && this.buffer.byteLength >= DP_PACK_MAGIC_LEN) {
+            const u8 = new Uint8Array(this.buffer);
+            if (u8[0] === exports.DP_PACK_MAGIC[0] && u8[1] === exports.DP_PACK_MAGIC[1] && u8[2] === exports.DP_PACK_MAGIC[2])
+                this.offset = DP_PACK_MAGIC_LEN;
+        }
+    }
+    writeStructBegin(_struct) {
+        this.ensureMagicWritten();
+    }
+    writeStructEnd() { }
+    writeFieldBegin(field) {
+        this.ensureMagicWritten();
+        if (field.type === DpWireType.Stop) {
+            this.writeByte(DpWireType.Stop);
+        }
+        else {
+            this.writeByte((field.id << 4) | field.type);
+        }
+    }
+    writeFieldEnd() { }
+    writeFieldStop() {
+        this.ensureMagicWritten();
+        this.writeByte(DpWireType.Stop);
+    }
+    writeBool(value) {
+        this.writeByte(value ? 1 : 0);
+    }
+    writeByte(value) {
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    writeI16(value) {
+        this.writeVarint(value);
+    }
+    writeI32(value) {
+        this.writeVarint(value);
+    }
+    writeI64(value) {
+        this.writeVarint64(value);
+    }
+    writeDouble(value) {
+        this.view.setFloat64(this.offset, value, this.littleEndian);
+        this.offset += 8;
+    }
+    writeString(value) {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(value);
+        this.writeVarint(bytes.length);
+        new Uint8Array(this.buffer, this.offset, bytes.length).set(bytes);
+        this.offset += bytes.length;
+    }
+    writeBinary(value) {
+        this.writeVarint(value.length);
+        new Uint8Array(this.buffer, this.offset, value.length).set(value);
+        this.offset += value.length;
+    }
+    writeListBegin(list) {
+        this.writeByte((list.elementType << 4) | (list.count < 15 ? list.count : 15));
+        if (list.count >= 15) {
+            this.writeVarint(list.count - 15);
+        }
+    }
+    writeListEnd() { }
+    writeSetBegin(set) {
+        this.writeListBegin({ elementType: set.elementType, count: set.count });
+    }
+    writeSetEnd() { }
+    writeMapBegin(map) {
+        this.writeVarint(map.count);
+        if (map.count > 0) {
+            this.writeByte((map.keyType << 4) | map.valueType);
+        }
+    }
+    writeMapEnd() { }
+    readStructBegin() {
+        this.ensureMagicSkipped();
+        return { name: '' };
+    }
+    readStructEnd() { }
+    readFieldBegin() {
+        this.ensureMagicSkipped();
+        const byte = this.readByte();
+        if (byte === DpWireType.Stop) {
+            return { name: '', type: DpWireType.Stop, id: 0 };
+        }
+        const type = byte & 0x0F;
+        const id = byte >> 4;
+        return { name: '', type: type, id };
+    }
+    readFieldEnd() { }
+    readBool() {
+        return this.readByte() !== 0;
+    }
+    readByte() {
+        const value = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+    readI16() {
+        return this.readVarint();
+    }
+    readI32() {
+        return this.readVarint();
+    }
+    readI64() {
+        return this.readVarint64();
+    }
+    readDouble() {
+        const value = this.view.getFloat64(this.offset, this.littleEndian);
+        this.offset += 8;
+        return value;
+    }
+    readString() {
+        const length = this.readVarint();
+        const bytes = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        return new TextDecoder().decode(bytes);
+    }
+    readBinary() {
+        const length = this.readVarint();
+        const bytes = new Uint8Array(this.buffer, this.offset, length);
+        this.offset += length;
+        return new Uint8Array(bytes);
+    }
+    readListBegin() {
+        const byte = this.readByte();
+        const elementType = byte & 0x0F;
+        let count = byte >> 4;
+        if (count === 15) {
+            count = this.readVarint() + 15;
+        }
+        return { elementType: elementType, count };
+    }
+    readListEnd() { }
+    readSetBegin() {
+        const list = this.readListBegin();
+        return { elementType: list.elementType, count: list.count };
+    }
+    readSetEnd() { }
+    readMapBegin() {
+        const count = this.readVarint();
+        if (count === 0) {
+            return { keyType: DpWireType.Stop, valueType: DpWireType.Stop, count: 0 };
+        }
+        const byte = this.readByte();
+        const keyType = byte >> 4;
+        const valueType = byte & 0x0F;
+        return { keyType: keyType, valueType: valueType, count };
+    }
+    readMapEnd() { }
+    writeVarint(value) {
+        while (value > 0x7F) {
+            this.writeByte((value & 0x7F) | 0x80);
+            value >>>= 7;
+        }
+        this.writeByte(value & 0x7F);
+    }
+    readVarint() {
+        let result = 0;
+        let shift = 0;
+        let byte;
+        do {
+            byte = this.readByte();
+            result |= (byte & 0x7F) << shift;
+            shift += 7;
+        } while (byte & 0x80);
+        return result;
+    }
+    writeVarint64(value) {
+        while (value > 0x7fn) {
+            this.writeByte(Number((value & 0x7fn) | 0x80n));
+            value = value >> 7n;
+        }
+        this.writeByte(Number(value & 0x7fn));
+    }
+    readVarint64() {
+        let result = 0n;
+        let shift = 0n;
+        let byte;
+        do {
+            byte = this.readByte();
+            result |= BigInt(byte & 0x7F) << shift;
+            shift += 7n;
+        } while (byte & 0x80);
+        return result;
+    }
+    getBuffer() {
+        return this.buffer.slice(0, this.offset);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    setOffset(offset) {
+        this.offset = offset;
+    }
+}
+exports.DpPackProtocol = DpPackProtocol;
+/**
+ * Unpack 시 저장된 바이트에서 프로토콜 판별.
+ * - 엔벨로프(4바이트)가 있으면 그 안의 프로토콜 타입 반환.
+ * - pack 매직(3바이트)만 있으면 'pack'.
+ * - 매직이 없으면 Thrift 호환 바이너리로 간주하여 'binary' 반환.
+ */
+function detectWireProtocol(buffer) {
+    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    const env = readEnvelope(bytes);
+    if (env)
+        return env.protocol;
+    if (bytes.length >= DP_PACK_MAGIC_LEN &&
+        bytes[0] === exports.DP_PACK_MAGIC[0] &&
+        bytes[1] === exports.DP_PACK_MAGIC[1] &&
+        bytes[2] === exports.DP_PACK_MAGIC[2]) {
+        return 'pack';
+    }
+    return 'binary';
+}
+/**
+ * Unpack 시 버퍼에서 프로토콜 타입을 읽고, 해당 프로토콜 인스턴스와 바디 시작 오프셋 반환.
+ * 엔벨로프 있음 → bodyOffset=4. pack 매직만 있음 → bodyOffset=3. 매직 없음 → Thrift 호환 바이너리, bodyOffset=0.
+ */
+function createProtocolForUnpack(buffer, littleEndian = true) {
+    const env = readEnvelope(buffer);
+    if (env) {
+        const proto = env.protocol === 'binary' ? new DpBinaryProtocol(buffer, littleEndian)
+            : env.protocol === 'compact' ? new DpCompactProtocol(buffer, littleEndian)
+                : env.protocol === 'zerocopy' ? new DpZeroCopyProtocol(buffer, littleEndian)
+                    : new DpPackProtocol(buffer, littleEndian);
+        proto.setOffset(exports.DP_WIRE_ENVELOPE_SIZE);
+        return { protocol: proto, bodyOffset: exports.DP_WIRE_ENVELOPE_SIZE };
+    }
+    const bytes = new Uint8Array(buffer);
+    if (bytes.length >= DP_PACK_MAGIC_LEN &&
+        bytes[0] === exports.DP_PACK_MAGIC[0] &&
+        bytes[1] === exports.DP_PACK_MAGIC[1] &&
+        bytes[2] === exports.DP_PACK_MAGIC[2]) {
+        const proto = new DpPackProtocol(buffer, littleEndian);
+        proto.setOffset(DP_PACK_MAGIC_LEN);
+        return { protocol: proto, bodyOffset: DP_PACK_MAGIC_LEN };
+    }
+    const proto = new DpBinaryProtocol(buffer, littleEndian);
+    return { protocol: proto, bodyOffset: 0 };
+}
+//# sourceMappingURL=WireProtocol.js.map