deukpack 1.0.0 → 1.0.1

package/binding.gyp

@@ -0,0 +1,41 @@
+{
+  "targets": [
+    {
+      "target_name": "thrift_fast_engine",
+      "sources": [
+        "native/cpp/src/thrift_engine.cpp",
+        "native/cpp/src/binary_writer.cpp",
+        "native/cpp/src/binary_reader.cpp",
+        "native/cpp/src/compact_writer.cpp",
+        "native/cpp/src/compact_reader.cpp"
+      ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")",
+        "native/cpp/include"
+      ],
+      "defines": [
+        "NAPI_DISABLE_CPP_EXCEPTIONS"
+      ],
+      "cflags!": ["-fno-exceptions"],
+      "cflags_cc!": ["-fno-exceptions"],
+      "xcode_settings": {
+        "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+        "CLANG_CXX_LIBRARY": "libc++",
+        "MACOSX_DEPLOYMENT_TARGET": "10.7"
+      },
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          "ExceptionHandling": 1
+        }
+      },
+      "conditions": [
+        ["OS=='win'", {
+          "defines": [
+            "WIN32_LEAN_AND_MEAN",
+            "NOMINMAX"
+          ]
+        }]
+      ]
+    }
+  ]
+}

package/native/cpp/include/binary_reader.h

@@ -0,0 +1,48 @@
+/**
+ * DeukPack Binary Reader Header
+ * High-performance binary deserialization
+ */
+
+#ifndef BINARY_READER_H
+#define BINARY_READER_H
+
+#include <vector>
+#include <cstdint>
+#include <string>
+#include "thrift_engine.h"
+
+namespace deukpack
+{
+
+    class BinaryReader
+    {
+    public:
+        explicit BinaryReader(const uint8_t *data, size_t size, Endianness endianness = Endianness::LITTLE_ENDIAN);
+        ~BinaryReader() = default;
+
+        // Basic types
+        uint8_t ReadByte();
+        int16_t ReadI16();
+        int32_t ReadI32();
+        int64_t ReadI64();
+        double ReadDouble();
+
+        // String and binary
+        std::string ReadString();
+        std::vector<uint8_t> ReadBinary();
+
+        // Buffer management
+        bool IsAtEnd() const;
+        size_t GetPosition() const;
+        void SetPosition(size_t position);
+
+    private:
+        const uint8_t *data_;
+        size_t size_;
+        size_t position_;
+        Endianness endianness_;
+    };
+
+} // namespace deukpack
+
+#endif // BINARY_READER_H

package/native/cpp/include/binary_writer.h

@@ -0,0 +1,53 @@
+/**
+ * DeukPack Binary Writer Header
+ * High-performance binary serialization
+ */
+
+#ifndef BINARY_WRITER_H
+#define BINARY_WRITER_H
+
+#include <vector>
+#include <cstdint>
+#include <string>
+#include "thrift_engine.h"
+
+namespace deukpack
+{
+
+    class BinaryWriter
+    {
+    public:
+        explicit BinaryWriter(Endianness endianness = Endianness::LITTLE_ENDIAN, size_t initialSize = 1024);
+        ~BinaryWriter() = default;
+
+        // Basic types
+        void WriteByte(uint8_t value);
+        void WriteI16(int16_t value);
+        void WriteI32(int32_t value);
+        void WriteI64(int64_t value);
+        void WriteDouble(double value);
+
+        // String and binary
+        void WriteString(const std::string &value);
+        void WriteBytes(const uint8_t *data, size_t length);
+        void WriteBinary(const std::vector<uint8_t> &data);
+
+        // Buffer management
+        std::vector<uint8_t> GetBuffer();
+        size_t GetPosition() const;
+        void Reset();
+
+    private:
+        void EnsureCapacity(size_t needed);
+        void FlushCurrentBuffer();
+        void AllocateNewBuffer(size_t size);
+
+        Endianness endianness_;
+        std::vector<uint8_t> currentBuffer_;
+        std::vector<std::vector<uint8_t>> buffers_;
+        size_t position_;
+    };
+
+} // namespace deukpack
+
+#endif // BINARY_WRITER_H

package/native/cpp/include/compact_reader.h

@@ -0,0 +1,35 @@
+/**
+ * DeukPack Compact Reader Header
+ * High-performance compact protocol deserialization
+ */
+
+#ifndef COMPACT_READER_H
+#define COMPACT_READER_H
+
+#include <cstdint>
+#include <string>
+
+namespace deukpack
+{
+
+    class CompactReader
+    {
+    public:
+        explicit CompactReader(const uint8_t *data, size_t size);
+        ~CompactReader() = default;
+
+        uint8_t ReadByte();
+        int32_t ReadVarInt();
+        std::string ReadString();
+
+        bool IsAtEnd() const;
+
+    private:
+        const uint8_t *data_;
+        size_t size_;
+        size_t position_;
+    };
+
+} // namespace deukpack
+
+#endif // COMPACT_READER_H

package/native/cpp/include/compact_writer.h

@@ -0,0 +1,43 @@
+/**
+ * DeukPack Compact Writer Header
+ * High-performance compact protocol serialization
+ */
+
+#ifndef COMPACT_WRITER_H
+#define COMPACT_WRITER_H
+
+#include <vector>
+#include <cstdint>
+#include <string>
+#include <cstring>
+
+namespace deukpack
+{
+
+    class CompactWriter
+    {
+    public:
+        explicit CompactWriter(size_t initialSize = 1024);
+        ~CompactWriter() = default;
+
+        void WriteByte(uint8_t value);
+        void WriteVarInt(int32_t value);
+        void WriteString(const std::string &value);
+        void WriteBytes(const uint8_t *data, size_t length);
+
+        std::vector<uint8_t> GetBuffer();
+        void Reset();
+
+    private:
+        void EnsureCapacity(size_t needed);
+        void FlushCurrentBuffer();
+        void AllocateNewBuffer(size_t size);
+
+        std::vector<uint8_t> currentBuffer_;
+        std::vector<std::vector<uint8_t>> buffers_;
+        size_t position_;
+    };
+
+} // namespace deukpack
+
+#endif // COMPACT_WRITER_H

package/native/cpp/include/thrift_engine.h

@@ -0,0 +1,187 @@
+/**
+ * DeukPack Native C++ Header
+ * High-performance Thrift engine implementation
+ */
+
+#ifndef THRIFT_ENGINE_H
+#define THRIFT_ENGINE_H
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <memory>
+#include <chrono>
+
+namespace deukpack
+{
+
+    // Forward declarations
+    struct ThriftAST;
+    struct ThriftStruct;
+    struct ThriftEnum;
+    struct ThriftService;
+    struct ThriftField;
+    struct ThriftNamespace;
+    struct SerializationOptions;
+
+    // Thrift types
+    enum class ThriftType
+    {
+        BOOL,
+        BYTE,
+        I16,
+        I32,
+        I64,
+        DOUBLE,
+        STRING,
+        BINARY,
+        LIST,
+        SET,
+        MAP,
+        STRUCT,
+        ENUM
+    };
+
+    enum class Endianness
+    {
+        LITTLE_ENDIAN,
+        BIG_ENDIAN
+    };
+
+    enum class ThriftProtocol
+    {
+        BINARY,
+        COMPACT,
+        JSON
+    };
+
+    // Thrift field definition
+    struct ThriftField
+    {
+        int32_t id;
+        std::string name;
+        ThriftType type;
+        bool required;
+        std::string defaultValue;
+        ThriftType elementType;
+        ThriftType keyType;
+        ThriftType valueType;
+        std::string structType;
+        std::unordered_map<std::string, int32_t> enumValues;
+    };
+
+    // Thrift struct definition
+    struct ThriftStruct
+    {
+        std::string name;
+        std::vector<ThriftField> fields;
+        std::unordered_map<std::string, std::string> annotations;
+    };
+
+    // Thrift enum definition
+    struct ThriftEnum
+    {
+        std::string name;
+        std::unordered_map<std::string, int32_t> values;
+        std::unordered_map<std::string, std::string> annotations;
+    };
+
+    // Thrift method definition
+    struct ThriftMethod
+    {
+        std::string name;
+        ThriftType returnType;
+        std::vector<ThriftField> parameters;
+        bool oneway;
+        std::unordered_map<std::string, std::string> annotations;
+    };
+
+    // Thrift service definition
+    struct ThriftService
+    {
+        std::string name;
+        std::vector<ThriftMethod> methods;
+        std::unordered_map<std::string, std::string> annotations;
+    };
+
+    // Thrift namespace definition
+    struct ThriftNamespace
+    {
+        std::string language;
+        std::string name;
+    };
+
+    // Thrift AST
+    struct ThriftAST
+    {
+        std::vector<ThriftNamespace> namespaces;
+        std::vector<ThriftStruct> structs;
+        std::vector<ThriftEnum> enums;
+        std::vector<ThriftService> services;
+        std::vector<std::string> includes;
+        std::unordered_map<std::string, std::string> annotations;
+    };
+
+    // Serialization options
+    struct SerializationOptions
+    {
+        ThriftProtocol protocol;
+        Endianness endianness;
+        bool optimizeForSize;
+        bool includeDefaultValues;
+        bool validateTypes;
+    };
+
+    // Performance metrics
+    struct PerformanceMetrics
+    {
+        double parseTime;
+        double generateTime;
+        double serializeTime;
+        double deserializeTime;
+        size_t memoryUsage;
+        int32_t fileCount;
+        int32_t lineCount;
+    };
+
+    // Main Thrift Engine class
+    class ThriftEngine
+    {
+    public:
+        ThriftEngine();
+        ~ThriftEngine();
+
+        // Parse Thrift files
+        ThriftAST ParseFiles(const std::vector<std::string> &filePaths);
+
+        // Serialize object
+        std::vector<uint8_t> Serialize(const std::unordered_map<std::string, std::string> &data, const SerializationOptions &options);
+
+        // Deserialize data
+        std::unordered_map<std::string, std::string> Deserialize(const std::vector<uint8_t> &data, const SerializationOptions &options);
+
+        // Get memory usage
+        size_t GetMemoryUsage() const;
+
+        // Get performance metrics
+        PerformanceMetrics GetPerformanceMetrics() const;
+
+        // Reset metrics
+        void ResetMetrics();
+
+    private:
+        class Impl;
+        std::unique_ptr<Impl> impl_;
+    };
+
+    // Utility functions
+    std::string ThriftTypeToString(ThriftType type);
+    ThriftType StringToThriftType(const std::string &str);
+    std::string EndiannessToString(Endianness endianness);
+    Endianness StringToEndianness(const std::string &str);
+    std::string ProtocolToString(ThriftProtocol protocol);
+    ThriftProtocol StringToProtocol(const std::string &str);
+
+} // namespace deukpack
+
+#endif // THRIFT_ENGINE_H

package/native/cpp/src/binary_reader.cpp

@@ -0,0 +1,177 @@
+/**
+ * DeukPack Binary Reader
+ * High-performance binary deserialization
+ */
+
+#include "binary_reader.h"
+#include <cstring>
+#include <algorithm>
+
+namespace deukpack
+{
+
+    BinaryReader::BinaryReader(const uint8_t *data, size_t size, Endianness endianness)
+        : data_(data), size_(size), position_(0), endianness_(endianness)
+    {
+    }
+
+    uint8_t BinaryReader::ReadByte()
+    {
+        if (position_ >= size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+        return data_[position_++];
+    }
+
+    int16_t BinaryReader::ReadI16()
+    {
+        if (position_ + 2 > size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+
+        int16_t value;
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            value = data_[position_] | (data_[position_ + 1] << 8);
+        }
+        else
+        {
+            value = (data_[position_] << 8) | data_[position_ + 1];
+        }
+
+        position_ += 2;
+        return value;
+    }
+
+    int32_t BinaryReader::ReadI32()
+    {
+        if (position_ + 4 > size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+
+        int32_t value;
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            value = data_[position_] |
+                    (data_[position_ + 1] << 8) |
+                    (data_[position_ + 2] << 16) |
+                    (data_[position_ + 3] << 24);
+        }
+        else
+        {
+            value = (data_[position_] << 24) |
+                    (data_[position_ + 1] << 16) |
+                    (data_[position_ + 2] << 8) |
+                    data_[position_ + 3];
+        }
+
+        position_ += 4;
+        return value;
+    }
+
+    int64_t BinaryReader::ReadI64()
+    {
+        if (position_ + 8 > size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+
+        int64_t value = 0;
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            for (int i = 0; i < 8; i++)
+            {
+                value |= static_cast<int64_t>(data_[position_ + i]) << (i * 8);
+            }
+        }
+        else
+        {
+            for (int i = 0; i < 8; i++)
+            {
+                value |= static_cast<int64_t>(data_[position_ + i]) << ((7 - i) * 8);
+            }
+        }
+
+        position_ += 8;
+        return value;
+    }
+
+    double BinaryReader::ReadDouble()
+    {
+        if (position_ + 8 > size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+
+        union
+        {
+            double d;
+            uint8_t bytes[8];
+        } converter;
+
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            std::memcpy(converter.bytes, &data_[position_], 8);
+        }
+        else
+        {
+            // Reverse byte order for big endian
+            for (int i = 0; i < 8; i++)
+            {
+                converter.bytes[i] = data_[position_ + 7 - i];
+            }
+        }
+
+        position_ += 8;
+        return converter.d;
+    }
+
+    std::string BinaryReader::ReadString()
+    {
+        int32_t length = ReadI32();
+        if (position_ + length > size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+
+        std::string result(reinterpret_cast<const char *>(&data_[position_]), length);
+        position_ += length;
+        return result;
+    }
+
+    std::vector<uint8_t> BinaryReader::ReadBinary()
+    {
+        int32_t length = ReadI32();
+        if (position_ + length > size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+
+        std::vector<uint8_t> result(data_ + position_, data_ + position_ + length);
+        position_ += length;
+        return result;
+    }
+
+    bool BinaryReader::IsAtEnd() const
+    {
+        return position_ >= size_;
+    }
+
+    size_t BinaryReader::GetPosition() const
+    {
+        return position_;
+    }
+
+    void BinaryReader::SetPosition(size_t position)
+    {
+        if (position > size_)
+        {
+            throw std::runtime_error("Position out of bounds");
+        }
+        position_ = position;
+    }
+
+} // namespace deukpack

package/native/cpp/src/binary_writer.cpp

@@ -0,0 +1,211 @@
+/**
+ * DeukPack Binary Writer
+ * High-performance binary serialization
+ */
+
+#include "binary_writer.h"
+#include <cstring>
+#include <algorithm>
+
+namespace deukpack
+{
+
+    BinaryWriter::BinaryWriter(Endianness endianness, size_t initialSize)
+        : endianness_(endianness), position_(0)
+    {
+        currentBuffer_.resize(initialSize);
+    }
+
+    void BinaryWriter::WriteByte(uint8_t value)
+    {
+        EnsureCapacity(1);
+        currentBuffer_[position_++] = value;
+    }
+
+    void BinaryWriter::WriteI16(int16_t value)
+    {
+        EnsureCapacity(2);
+
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            currentBuffer_[position_] = value & 0xFF;
+            currentBuffer_[position_ + 1] = (value >> 8) & 0xFF;
+        }
+        else
+        {
+            currentBuffer_[position_] = (value >> 8) & 0xFF;
+            currentBuffer_[position_ + 1] = value & 0xFF;
+        }
+
+        position_ += 2;
+    }
+
+    void BinaryWriter::WriteI32(int32_t value)
+    {
+        EnsureCapacity(4);
+
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            currentBuffer_[position_] = value & 0xFF;
+            currentBuffer_[position_ + 1] = (value >> 8) & 0xFF;
+            currentBuffer_[position_ + 2] = (value >> 16) & 0xFF;
+            currentBuffer_[position_ + 3] = (value >> 24) & 0xFF;
+        }
+        else
+        {
+            currentBuffer_[position_] = (value >> 24) & 0xFF;
+            currentBuffer_[position_ + 1] = (value >> 16) & 0xFF;
+            currentBuffer_[position_ + 2] = (value >> 8) & 0xFF;
+            currentBuffer_[position_ + 3] = value & 0xFF;
+        }
+
+        position_ += 4;
+    }
+
+    void BinaryWriter::WriteI64(int64_t value)
+    {
+        EnsureCapacity(8);
+
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            for (int i = 0; i < 8; i++)
+            {
+                currentBuffer_[position_ + i] = (value >> (i * 8)) & 0xFF;
+            }
+        }
+        else
+        {
+            for (int i = 0; i < 8; i++)
+            {
+                currentBuffer_[position_ + i] = (value >> ((7 - i) * 8)) & 0xFF;
+            }
+        }
+
+        position_ += 8;
+    }
+
+    void BinaryWriter::WriteDouble(double value)
+    {
+        EnsureCapacity(8);
+
+        // Convert to IEEE 754 representation
+        union
+        {
+            double d;
+            uint8_t bytes[8];
+        } converter;
+
+        converter.d = value;
+
+        if (endianness_ == Endianness::LITTLE_ENDIAN)
+        {
+            std::memcpy(&currentBuffer_[position_], converter.bytes, 8);
+        }
+        else
+        {
+            // Reverse byte order for big endian
+            for (int i = 0; i < 8; i++)
+            {
+                currentBuffer_[position_ + i] = converter.bytes[7 - i];
+            }
+        }
+
+        position_ += 8;
+    }
+
+    void BinaryWriter::WriteString(const std::string &value)
+    {
+        WriteI32(static_cast<int32_t>(value.length()));
+        WriteBytes(reinterpret_cast<const uint8_t *>(value.c_str()), value.length());
+    }
+
+    void BinaryWriter::WriteBytes(const uint8_t *data, size_t length)
+    {
+        EnsureCapacity(length);
+        std::memcpy(&currentBuffer_[position_], data, length);
+        position_ += length;
+    }
+
+    void BinaryWriter::WriteBinary(const std::vector<uint8_t> &data)
+    {
+        WriteI32(static_cast<int32_t>(data.size()));
+        WriteBytes(data.data(), data.size());
+    }
+
+    std::vector<uint8_t> BinaryWriter::GetBuffer()
+    {
+        FlushCurrentBuffer();
+
+        if (buffers_.empty())
+        {
+            return std::vector<uint8_t>();
+        }
+
+        if (buffers_.size() == 1)
+        {
+            return std::move(buffers_[0]);
+        }
+
+        // Calculate total size
+        size_t totalSize = 0;
+        for (const auto &buffer : buffers_)
+        {
+            totalSize += buffer.size();
+        }
+
+        // Concatenate all buffers
+        std::vector<uint8_t> result;
+        result.reserve(totalSize);
+
+        for (const auto &buffer : buffers_)
+        {
+            result.insert(result.end(), buffer.begin(), buffer.end());
+        }
+
+        return result;
+    }
+
+    size_t BinaryWriter::GetPosition() const
+    {
+        size_t totalPosition = 0;
+        for (const auto &buffer : buffers_)
+        {
+            totalPosition += buffer.size();
+        }
+        return totalPosition + position_;
+    }
+
+    void BinaryWriter::Reset()
+    {
+        buffers_.clear();
+        position_ = 0;
+        currentBuffer_.resize(1024);
+    }
+
+    void BinaryWriter::EnsureCapacity(size_t needed)
+    {
+        if (position_ + needed > currentBuffer_.size())
+        {
+            FlushCurrentBuffer();
+            AllocateNewBuffer(std::max(needed * 2, static_cast<size_t>(1024)));
+        }
+    }
+
+    void BinaryWriter::FlushCurrentBuffer()
+    {
+        if (position_ > 0)
+        {
+            std::vector<uint8_t> buffer(position_);
+            std::memcpy(buffer.data(), currentBuffer_.data(), position_);
+            buffers_.push_back(std::move(buffer));
+            position_ = 0;
+        }
+    }
+
+    void BinaryWriter::AllocateNewBuffer(size_t size)
+    {
+        currentBuffer_.resize(size);
+        position_ = 0;
+    }
+
+} // namespace deukpack

package/native/cpp/src/compact_reader.cpp

@@ -0,0 +1,69 @@
+/**
+ * DeukPack Compact Reader
+ * High-performance compact protocol deserialization
+ */
+
+#include "compact_reader.h"
+#include <stdexcept>
+
+namespace deukpack
+{
+
+    CompactReader::CompactReader(const uint8_t *data, size_t size)
+        : data_(data), size_(size), position_(0)
+    {
+    }
+
+    uint8_t CompactReader::ReadByte()
+    {
+        if (position_ >= size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+        return data_[position_++];
+    }
+
+    int32_t CompactReader::ReadVarInt()
+    {
+        int32_t result = 0;
+        int shift = 0;
+
+        while (position_ < size_)
+        {
+            uint8_t byte = data_[position_++];
+            result |= (byte & 0x7F) << shift;
+
+            if ((byte & 0x80) == 0)
+            {
+                break;
+            }
+
+            shift += 7;
+            if (shift >= 32)
+            {
+                throw std::runtime_error("VarInt too large");
+            }
+        }
+
+        return result;
+    }
+
+    std::string CompactReader::ReadString()
+    {
+        int32_t length = ReadVarInt();
+        if (position_ + length > size_)
+        {
+            throw std::runtime_error("Buffer overflow");
+        }
+
+        std::string result(reinterpret_cast<const char *>(&data_[position_]), length);
+        position_ += length;
+        return result;
+    }
+
+    bool CompactReader::IsAtEnd() const
+    {
+        return position_ >= size_;
+    }
+
+} // namespace deukpack

package/native/cpp/src/compact_writer.cpp

@@ -0,0 +1,113 @@
+/**
+ * DeukPack Compact Writer
+ * High-performance compact protocol serialization
+ */
+
+#include "compact_writer.h"
+#include <cstring>
+
+namespace deukpack
+{
+
+    CompactWriter::CompactWriter(size_t initialSize)
+        : position_(0)
+    {
+        currentBuffer_.resize(initialSize);
+    }
+
+    void CompactWriter::WriteByte(uint8_t value)
+    {
+        EnsureCapacity(1);
+        currentBuffer_[position_++] = value;
+    }
+
+    void CompactWriter::WriteVarInt(int32_t value)
+    {
+        while (value >= 0x80)
+        {
+            WriteByte((value & 0x7F) | 0x80);
+            value >>= 7;
+        }
+        WriteByte(value & 0x7F);
+    }
+
+    void CompactWriter::WriteString(const std::string &value)
+    {
+        WriteVarInt(static_cast<int32_t>(value.length()));
+        WriteBytes(reinterpret_cast<const uint8_t *>(value.c_str()), value.length());
+    }
+
+    void CompactWriter::WriteBytes(const uint8_t *data, size_t length)
+    {
+        EnsureCapacity(length);
+        std::memcpy(&currentBuffer_[position_], data, length);
+        position_ += length;
+    }
+
+    std::vector<uint8_t> CompactWriter::GetBuffer()
+    {
+        FlushCurrentBuffer();
+
+        if (buffers_.empty())
+        {
+            return std::vector<uint8_t>();
+        }
+
+        if (buffers_.size() == 1)
+        {
+            return std::move(buffers_[0]);
+        }
+
+        // Calculate total size
+        size_t totalSize = 0;
+        for (const auto &buffer : buffers_)
+        {
+            totalSize += buffer.size();
+        }
+
+        // Concatenate all buffers
+        std::vector<uint8_t> result;
+        result.reserve(totalSize);
+
+        for (const auto &buffer : buffers_)
+        {
+            result.insert(result.end(), buffer.begin(), buffer.end());
+        }
+
+        return result;
+    }
+
+    void CompactWriter::Reset()
+    {
+        buffers_.clear();
+        position_ = 0;
+        currentBuffer_.resize(1024);
+    }
+
+    void CompactWriter::EnsureCapacity(size_t needed)
+    {
+        if (position_ + needed > currentBuffer_.size())
+        {
+            FlushCurrentBuffer();
+            AllocateNewBuffer(std::max(needed * 2, static_cast<size_t>(1024)));
+        }
+    }
+
+    void CompactWriter::FlushCurrentBuffer()
+    {
+        if (position_ > 0)
+        {
+            std::vector<uint8_t> buffer(position_);
+            std::memcpy(buffer.data(), currentBuffer_.data(), position_);
+            buffers_.push_back(std::move(buffer));
+            position_ = 0;
+        }
+    }
+
+    void CompactWriter::AllocateNewBuffer(size_t size)
+    {
+        currentBuffer_.resize(size);
+        position_ = 0;
+    }
+
+} // namespace deukpack

package/native/cpp/src/thrift_engine.cpp

@@ -0,0 +1,380 @@
+/**
+ * DeukPack Native C++ Implementation
+ * High-performance Thrift engine
+ */
+
+#include <napi.h>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <unordered_map>
+#include <memory>
+#include <chrono>
+#include "thrift_engine.h"
+#include "binary_writer.h"
+
+using namespace deukpack;
+
+// ThriftEngine implementation
+class ThriftEngine::Impl
+{
+public:
+    Impl() : memoryUsage_(0) {}
+
+    ThriftAST ParseFiles(const std::vector<std::string> &filePaths)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        ThriftAST ast;
+        // TODO: Implement actual parsing logic
+        // For now, return empty AST
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        parseTime_ = duration.count();
+
+        return ast;
+    }
+
+    std::vector<uint8_t> Serialize(const std::unordered_map<std::string, std::string> &data,
+                                   const SerializationOptions &options)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        BinaryWriter writer(options.endianness == Endianness::LITTLE_ENDIAN ? Endianness::LITTLE_ENDIAN : Endianness::BIG_ENDIAN);
+
+        // Simple serialization for demonstration
+        writer.WriteI32(static_cast<int32_t>(data.size()));
+        for (const auto &pair : data)
+        {
+            writer.WriteString(pair.first);
+            writer.WriteString(pair.second);
+        }
+
+        auto result = writer.GetBuffer();
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        serializeTime_ = duration.count();
+
+        return result;
+    }
+
+    std::unordered_map<std::string, std::string> Deserialize(const std::vector<uint8_t> &data,
+                                                             const SerializationOptions &options)
+    {
+        auto start = std::chrono::high_resolution_clock::now();
+
+        std::unordered_map<std::string, std::string> result;
+
+        // Simple deserialization for demonstration
+        if (data.size() >= 4)
+        {
+            int32_t count = *reinterpret_cast<const int32_t *>(data.data());
+            size_t offset = 4;
+
+            for (int32_t i = 0; i < count && offset < data.size(); i++)
+            {
+                if (offset + 4 > data.size())
+                    break;
+
+                int32_t keyLen = *reinterpret_cast<const int32_t *>(data.data() + offset);
+                offset += 4;
+
+                if (offset + keyLen > data.size())
+                    break;
+                std::string key(data.data() + offset, data.data() + offset + keyLen);
+                offset += keyLen;
+
+                if (offset + 4 > data.size())
+                    break;
+                int32_t valueLen = *reinterpret_cast<const int32_t *>(data.data() + offset);
+                offset += 4;
+
+                if (offset + valueLen > data.size())
+                    break;
+                std::string value(data.data() + offset, data.data() + offset + valueLen);
+                offset += valueLen;
+
+                result[key] = value;
+            }
+        }
+
+        auto end = std::chrono::high_resolution_clock::now();
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+        deserializeTime_ = duration.count();
+
+        return result;
+    }
+
+    size_t GetMemoryUsage() const
+    {
+        return memoryUsage_;
+    }
+
+    PerformanceMetrics GetPerformanceMetrics() const
+    {
+        PerformanceMetrics metrics;
+        metrics.parseTime = parseTime_;
+        metrics.generateTime = generateTime_;
+        metrics.serializeTime = serializeTime_;
+        metrics.deserializeTime = deserializeTime_;
+        metrics.memoryUsage = memoryUsage_;
+        metrics.fileCount = fileCount_;
+        metrics.lineCount = lineCount_;
+        return metrics;
+    }
+
+    void ResetMetrics()
+    {
+        parseTime_ = 0;
+        generateTime_ = 0;
+        serializeTime_ = 0;
+        deserializeTime_ = 0;
+        memoryUsage_ = 0;
+        fileCount_ = 0;
+        lineCount_ = 0;
+    }
+
+private:
+    double parseTime_ = 0;
+    double generateTime_ = 0;
+    double serializeTime_ = 0;
+    double deserializeTime_ = 0;
+    size_t memoryUsage_ = 0;
+    int32_t fileCount_ = 0;
+    int32_t lineCount_ = 0;
+};
+
+ThriftEngine::ThriftEngine() : impl_(std::make_unique<Impl>()) {}
+ThriftEngine::~ThriftEngine() = default;
+
+ThriftAST ThriftEngine::ParseFiles(const std::vector<std::string> &filePaths)
+{
+    return impl_->ParseFiles(filePaths);
+}
+
+std::vector<uint8_t> ThriftEngine::Serialize(const std::unordered_map<std::string, std::string> &data,
+                                             const SerializationOptions &options)
+{
+    return impl_->Serialize(data, options);
+}
+
+std::unordered_map<std::string, std::string> ThriftEngine::Deserialize(const std::vector<uint8_t> &data,
+                                                                       const SerializationOptions &options)
+{
+    return impl_->Deserialize(data, options);
+}
+
+size_t ThriftEngine::GetMemoryUsage() const
+{
+    return impl_->GetMemoryUsage();
+}
+
+PerformanceMetrics ThriftEngine::GetPerformanceMetrics() const
+{
+    return impl_->GetPerformanceMetrics();
+}
+
+void ThriftEngine::ResetMetrics()
+{
+    impl_->ResetMetrics();
+}
+
+// N-API wrapper functions
+Napi::Value CreateEngine(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    try
+    {
+        auto engine = std::make_unique<ThriftEngine>();
+        return Napi::External<ThriftEngine>::New(env, engine.release());
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value ParseFiles(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsExternal() || !info[1].IsArray())
+    {
+        Napi::TypeError::New(env, "Expected engine and file paths array").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto filePaths = info[1].As<Napi::Array>();
+
+        std::vector<std::string> paths;
+        for (uint32_t i = 0; i < filePaths.Length(); i++)
+        {
+            if (filePaths.Get(i).IsString())
+            {
+                paths.push_back(filePaths.Get(i).As<Napi::String>().Utf8Value());
+            }
+        }
+
+        auto ast = engine->ParseFiles(paths);
+
+        // Convert AST to JavaScript object
+        auto result = Napi::Object::New(env);
+        result.Set("namespaces", Napi::Array::New(env));
+        result.Set("structs", Napi::Array::New(env));
+        result.Set("enums", Napi::Array::New(env));
+        result.Set("services", Napi::Array::New(env));
+        result.Set("includes", Napi::Array::New(env));
+
+        return result;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value Serialize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsExternal() || !info[1].IsObject() || !info[2].IsObject())
+    {
+        Napi::TypeError::New(env, "Expected engine, data object, and options object").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto dataObj = info[1].As<Napi::Object>();
+        auto optionsObj = info[2].As<Napi::Object>();
+
+        // Convert JavaScript object to map
+        std::unordered_map<std::string, std::string> data;
+        auto keys = dataObj.GetPropertyNames();
+        for (uint32_t i = 0; i < keys.Length(); i++)
+        {
+            auto key = keys.Get(i).As<Napi::String>().Utf8Value();
+            auto value = dataObj.Get(key).As<Napi::String>().Utf8Value();
+            data[key] = value;
+        }
+
+        // Create serialization options
+        SerializationOptions options;
+        options.protocol = ThriftProtocol::BINARY;
+        options.endianness = Endianness::LITTLE_ENDIAN;
+        options.optimizeForSize = true;
+        options.includeDefaultValues = false;
+        options.validateTypes = true;
+
+        auto result = engine->Serialize(data, options);
+
+        // Convert to Node.js Buffer
+        auto buffer = Napi::Buffer<uint8_t>::Copy(env, result.data(), result.size());
+        return buffer;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value Deserialize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsExternal() || !info[1].IsBuffer() || !info[2].IsObject())
+    {
+        Napi::TypeError::New(env, "Expected engine, buffer, and options object").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto buffer = info[1].As<Napi::Buffer<uint8_t>>();
+        auto optionsObj = info[2].As<Napi::Object>();
+
+        // Convert buffer to vector
+        std::vector<uint8_t> data(buffer.Data(), buffer.Data() + buffer.Length());
+
+        // Create serialization options
+        SerializationOptions options;
+        options.protocol = ThriftProtocol::BINARY;
+        options.endianness = Endianness::LITTLE_ENDIAN;
+        options.optimizeForSize = true;
+        options.includeDefaultValues = false;
+        options.validateTypes = true;
+
+        auto result = engine->Deserialize(data, options);
+
+        // Convert map to JavaScript object
+        auto resultObj = Napi::Object::New(env);
+        for (const auto &pair : result)
+        {
+            resultObj.Set(pair.first, pair.second);
+        }
+
+        return resultObj;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Value GetPerformanceMetrics(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsExternal())
+    {
+        Napi::TypeError::New(env, "Expected engine").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    try
+    {
+        auto engine = info[0].As<Napi::External<ThriftEngine>>().Data();
+        auto metrics = engine->GetPerformanceMetrics();
+
+        auto result = Napi::Object::New(env);
+        result.Set("parseTime", metrics.parseTime);
+        result.Set("generateTime", metrics.generateTime);
+        result.Set("serializeTime", metrics.serializeTime);
+        result.Set("deserializeTime", metrics.deserializeTime);
+        result.Set("memoryUsage", static_cast<double>(metrics.memoryUsage));
+        result.Set("fileCount", metrics.fileCount);
+        result.Set("lineCount", metrics.lineCount);
+
+        return result;
+    }
+    catch (const std::exception &e)
+    {
+        Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    exports.Set(Napi::String::New(env, "createEngine"), Napi::Function::New(env, CreateEngine));
+    exports.Set(Napi::String::New(env, "parseFiles"), Napi::Function::New(env, ParseFiles));
+    exports.Set(Napi::String::New(env, "serialize"), Napi::Function::New(env, Serialize));
+    exports.Set(Napi::String::New(env, "deserialize"), Napi::Function::New(env, Deserialize));
+    exports.Set(Napi::String::New(env, "getPerformanceMetrics"), Napi::Function::New(env, GetPerformanceMetrics));
+
+    return exports;
+}
+
+NODE_API_MODULE(thrift_engine_native, Init)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deukpack",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "DeukPack — multi-format IDL pipeline (.deuk native, Protobuf, OpenAPI, JSON Schema, CSV, Thrift). Protobuf-aligned wire; fast C#/C++/JS codegen, CLI. v1: no Excel/table editor workflow",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
     "build:native": "node-gyp rebuild",
     "build:all": "npm run build && npm run build:cpp && npm run build:cs",
     "build:cpp": "cd native/cpp && mkdir -p build && cd build && cmake .. && make",
-    "build:cs": "cd native/csharp && dotnet build -c Release",
+    "build:cs": "cd DeukPack.Protocol && dotnet build -c Release",
     "test": "jest",
     "benchmark": "node benchmarks/performance.js",
     "dev": "tsc --watch",
@@ -65,6 +65,8 @@
     "bin",
     "scripts/build_deukpack.js",
     "dist",
+    "native/cpp",
+    "binding.gyp",
     "LICENSE",
     "NOTICE",
     "README.md",