@technoculture/data-bridge 0.1.1 → 0.1.2

package/CMakeLists.txt

@@ -3,8 +3,16 @@ project(data_bridge_node)
 
 set(CMAKE_CXX_STANDARD 17)
 
-# Root of the data-bridge project
-get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../.." ABSOLUTE)
+# Check for bundled dependencies (NPM package mode)
+set(LOCAL_DEPS "${CMAKE_CURRENT_SOURCE_DIR}/deps")
+if(EXISTS "${LOCAL_DEPS}/include")
+    message(STATUS "Using bundled dependencies in ${LOCAL_DEPS}")
+    set(PROJECT_ROOT "${LOCAL_DEPS}")
+else()
+    # Development mode (Monorepo)
+    get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../.." ABSOLUTE)
+    message(STATUS "Using development source root: ${PROJECT_ROOT}")
+endif()
 
 # Include Node-API headers
 include_directories(${CMAKE_JS_INC})

package/deps/include/data_bridge/config.hpp

@@ -0,0 +1,69 @@
+#pragma once
+#include <cstdlib>
+#include <cstdint>
+#include <string>
+
+/**
+ * Configuration for Data Bridge protocol.
+ * 
+ * Parameters can be set via environment variables.
+ * If not set, defaults are used.
+ * 
+ * Environment variables:
+ *   DATA_BRIDGE_MAX_RETRIES      - Maximum retry attempts (default: 10)
+ *   DATA_BRIDGE_RETRY_TIMEOUT_MS - Timeout between retries in ms (default: 2000)
+ *   DATA_BRIDGE_FRAGMENT_SIZE    - Maximum fragment payload size (default: 256)
+ *   DATA_BRIDGE_ACK_TIMEOUT_MS   - Timeout waiting for ACK in ms (default: 500)
+ */
+
+namespace DataBridgeConfig {
+
+inline int getEnvInt(const char* name, int defaultValue) {
+    const char* val = std::getenv(name);
+    if (val == nullptr) return defaultValue;
+    try {
+        return std::stoi(val);
+    } catch (...) {
+        return defaultValue;
+    }
+}
+
+// Maximum number of retry attempts before giving up
+inline uint8_t maxRetries() {
+    static uint8_t value = static_cast<uint8_t>(
+        getEnvInt("DATA_BRIDGE_MAX_RETRIES", 10)
+    );
+    return value;
+}
+
+// Timeout between retries in milliseconds
+inline uint16_t retryTimeoutMs() {
+    static uint16_t value = static_cast<uint16_t>(
+        getEnvInt("DATA_BRIDGE_RETRY_TIMEOUT_MS", 2000)
+    );
+    return value;
+}
+
+// Maximum payload size per fragment (for large message fragmentation)
+inline uint16_t fragmentSize() {
+    static uint16_t value = static_cast<uint16_t>(
+        getEnvInt("DATA_BRIDGE_FRAGMENT_SIZE", 256)
+    );
+    return value;
+}
+
+// Timeout waiting for ACK before retry
+inline uint16_t ackTimeoutMs() {
+    static uint16_t value = static_cast<uint16_t>(
+        getEnvInt("DATA_BRIDGE_ACK_TIMEOUT_MS", 500)
+    );
+    return value;
+}
+
+// Baud rate (default for most embedded devices)
+inline int baudRate() {
+    static int value = getEnvInt("DATA_BRIDGE_BAUD_RATE", 115200);
+    return value;
+}
+
+} // namespace DataBridgeConfig

package/deps/include/data_bridge/protocol/crc16.hpp

@@ -0,0 +1,8 @@
+#pragma once
+#include <cstdint>
+#include <cstddef>
+
+
+uint16_t crc16_ccitt(const uint8_t* data , size_t len);
+
+

package/deps/include/data_bridge/protocol/crc32.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include <cstdint>
+#include <cstddef>
+
+class CRC32 {
+public:
+    static uint32_t calculate(const uint8_t* data, size_t length) {
+        uint32_t crc = 0xFFFFFFFF;
+        for (size_t i = 0; i < length; ++i) {
+            uint8_t byte = data[i];
+            crc = crc ^ byte;
+            for (int j = 0; j < 8; ++j) {
+                uint32_t mask = -(crc & 1);
+                crc = (crc >> 1) ^ (0xEDB88320 & mask);
+            }
+        }
+        return ~crc;
+    }
+};

package/deps/include/data_bridge/protocol/packet.hpp

@@ -0,0 +1,175 @@
+#pragma once
+#include <vector>
+#include <string>
+#include <cstdint>
+#include <utility>
+#include <cstring>
+#include <algorithm>
+#include <data_bridge/protocol/crc32.hpp>
+#include <data_bridge/config.hpp>
+
+// Cross-platform packed struct support
+#if defined(_MSC_VER)
+#define PACKED_STRUCT_BEGIN __pragma(pack(push, 1))
+#define PACKED_STRUCT_END __pragma(pack(pop))
+#define PACKED_ATTR
+#elif defined(__GNUC__) || defined(__clang__)
+#define PACKED_STRUCT_BEGIN
+#define PACKED_STRUCT_END
+#define PACKED_ATTR __attribute__((packed))
+#else
+#define PACKED_STRUCT_BEGIN
+#define PACKED_STRUCT_END
+#define PACKED_ATTR
+#endif
+
+struct Packet {
+    PACKED_STRUCT_BEGIN
+    struct Header {
+        uint8_t  type;
+        uint8_t  seq_id;
+        uint16_t fragment_id;
+        uint16_t total_frags;
+        uint16_t payload_len;
+        uint32_t crc32;
+    } PACKED_ATTR;
+    PACKED_STRUCT_END
+
+    // Packet Types
+    static constexpr uint8_t TYPE_DATA = 0x10;
+    static constexpr uint8_t TYPE_ACK  = 0x20;
+    static constexpr uint8_t TYPE_NACK = 0x30;
+    static constexpr uint8_t TYPE_SYN  = 0x40;
+    
+    // COBS delimiter
+    static constexpr uint8_t COBS_DELIMITER = 0x00;
+
+    // Configuration accessors (use env vars or defaults)
+    static uint8_t maxRetries() { return DataBridgeConfig::maxRetries(); }
+    static uint16_t retryTimeoutMs() { return DataBridgeConfig::retryTimeoutMs(); }
+    static uint16_t fragmentSize() { return DataBridgeConfig::fragmentSize(); }
+
+    struct Frame {
+        Header header;
+        std::vector<uint8_t> payload;
+        bool valid;
+    };
+    
+    // Consistent Overhead Byte Stuffing (COBS) Encoding
+    static std::vector<uint8_t> cobs_encode(const std::vector<uint8_t>& data) {
+        std::vector<uint8_t> encoded;
+        encoded.reserve(data.size() + data.size() / 254 + 2);
+
+        size_t code_idx = 0;
+        encoded.push_back(0); // Placeholder for the first code
+        uint8_t code = 1;
+
+        for (uint8_t byte : data) {
+            if (byte == 0) {
+                encoded[code_idx] = code;
+                code_idx = encoded.size();
+                encoded.push_back(0); // Placeholder for next code
+                code = 1;
+            } else {
+                encoded.push_back(byte);
+                code++;
+                if (code == 0xFF) { // Max run length reached
+                    encoded[code_idx] = code;
+                    code_idx = encoded.size();
+                    encoded.push_back(0);
+                    code = 1;
+                }
+            }
+        }
+        encoded[code_idx] = code;
+        return encoded;
+    }
+
+    // COBS Decoding
+    static std::vector<uint8_t> cobs_decode(const std::vector<uint8_t>& data) {
+        std::vector<uint8_t> decoded;
+        decoded.reserve(data.size());
+
+        size_t i = 0;
+        while (i < data.size()) {
+            uint8_t code = data[i];
+            i++;
+            if (code == 0) break; // Should not happen in valid COBS before delimiter
+
+            for (uint8_t j = 1; j < code; j++) {
+                if (i >= data.size()) return {}; // Error: truncated
+                decoded.push_back(data[i++]);
+            }
+            if (code < 0xFF && i < data.size()) {
+                decoded.push_back(0);
+            }
+        }
+        return decoded;
+    }
+
+    static std::vector<uint8_t> serialize(uint8_t type, uint8_t seq, const std::string& payload, uint16_t frag_id = 0, uint16_t total_frags = 1) {
+        Header header;
+        header.type = type;
+        header.seq_id = seq;
+        header.fragment_id = frag_id;
+        header.total_frags = total_frags;
+        header.payload_len = static_cast<uint16_t>(payload.size());
+        header.crc32 = 0; // Calculated later
+
+        std::vector<uint8_t> raw_packet;
+        raw_packet.resize(sizeof(Header) + payload.size());
+        
+        std::memcpy(raw_packet.data(), &header, sizeof(Header));
+        std::memcpy(raw_packet.data() + sizeof(Header), payload.data(), payload.size());
+
+        // Calculate CRC32 of Header + Payload (with CRC field zeroed)
+        uint32_t crc = CRC32::calculate(raw_packet.data(), raw_packet.size());
+        
+        // Update header with calculated CRC
+        header.crc32 = crc;
+        std::memcpy(raw_packet.data(), &header, sizeof(Header));
+
+        // Encode with COBS
+        std::vector<uint8_t> encoded = cobs_encode(raw_packet);
+        encoded.push_back(COBS_DELIMITER); 
+        return encoded;
+    }
+
+    static Frame deserialize(std::vector<uint8_t>& buffer) {
+        // Find delimiter
+        auto it = std::find(buffer.begin(), buffer.end(), COBS_DELIMITER);
+        if (it == buffer.end()) return {{}, {}, false}; // No complete frame yet
+
+        std::vector<uint8_t> frame_data(buffer.begin(), it);
+        buffer.erase(buffer.begin(), it + 1); // Remove processed frame + delimiter
+
+        if (frame_data.empty()) return {{}, {}, false};
+
+        std::vector<uint8_t> decoded = cobs_decode(frame_data);
+        if (decoded.size() < sizeof(Header)) return {{}, {}, false};
+
+        Header header;
+        std::memcpy(&header, decoded.data(), sizeof(Header));
+
+        // Validate Length
+        if (decoded.size() != sizeof(Header) + header.payload_len) return {{}, {}, false};
+
+        // Validate CRC
+        uint32_t received_crc = header.crc32;
+        
+        // Zero out CRC in buffer to recompute
+        Header* header_ptr = reinterpret_cast<Header*>(decoded.data());
+        header_ptr->crc32 = 0;
+        
+        uint32_t computed_crc = CRC32::calculate(decoded.data(), decoded.size());
+        
+        if (received_crc == computed_crc) {
+            std::vector<uint8_t> payload(decoded.begin() + sizeof(Header), decoded.end());
+            // Retrieve original header
+            header.crc32 = received_crc; 
+            return {header, payload, true};
+        }
+
+        return {{}, {}, false};
+    }
+};

package/deps/include/data_bridge/protocol/reassembler.hpp

@@ -0,0 +1,80 @@
+#pragma once
+#include <data_bridge/protocol/packet.hpp>
+#include <vector>
+#include <iostream>
+
+class Reassembler {
+public:
+    struct Result {
+        bool complete;
+        std::vector<uint8_t> payload;
+    };
+
+    Reassembler() : current_seq_id_(255), expected_frag_(0), active_(false) {}
+
+    // Returns true if fragment was accepted (in sequence).
+    // Caller should send ACK if this returns true.
+    // If returns false, caller might ignore or send NACK/ACK-of-last-good.
+    bool process_fragment(const Packet::Frame& frame) {
+        if (!frame.valid) return false;
+        
+        uint8_t seq = frame.header.seq_id;
+        uint16_t frag = frame.header.fragment_id;
+        
+        // New Sequence ?
+        if (seq != current_seq_id_) {
+             // Accept if it's a new message (logic can be more complex for strict strictness, 
+             // e.g. only seq+1, but for now accept any new seq as new message start)
+             if (frag == 0) {
+                 reset(seq);
+             } else {
+                 return false; // Received middle of new message without start?
+             }
+        }
+
+        if (frag != expected_frag_) {
+            // Out of order fragment
+            return false;
+        }
+
+        // Valid fragment
+        buffer_.insert(buffer_.end(), frame.payload.begin(), frame.payload.end());
+        expected_frag_++;
+        return true;
+    }
+
+    bool is_complete(const Packet::Frame& last_frame) const {
+         if (!active_) return false;
+         return expected_frag_ == last_frame.header.total_frags;
+    }
+
+    bool is_duplicate(const Packet::Frame& frame) const {
+         if (!active_) return false;
+         uint8_t seq = frame.header.seq_id;
+         uint16_t frag = frame.header.fragment_id;
+         return (seq == current_seq_id_ && frag < expected_frag_);
+    }
+
+    std::vector<uint8_t> get_data() const {
+        return buffer_;
+    }
+
+    size_t get_buffered_size() const {
+        return buffer_.size();
+    }
+
+    uint8_t get_current_seq() const { return current_seq_id_; }
+
+private:
+    void reset(uint8_t seq) {
+        buffer_.clear();
+        current_seq_id_ = seq;
+        expected_frag_ = 0;
+        active_ = true;
+    }
+
+    uint8_t current_seq_id_;
+    uint16_t expected_frag_;
+    std::vector<uint8_t> buffer_;
+    bool active_;
+};

package/deps/include/data_bridge/transport/iserial_port.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include <vector>
+#include <string>
+#include <cstdint>
+
+class ISerialPort {
+public:
+    virtual ~ISerialPort() = default;
+
+    virtual bool open(const std::string& port_name, int baud_rate) = 0;
+    virtual void close() = 0;
+    
+    virtual int write(const std::vector<uint8_t>& data) = 0;
+    virtual int read(uint8_t* buffer, size_t size) = 0;
+};

package/deps/include/data_bridge/transport/serial_port.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <memory>
+#include <vector>
+#include <string>
+
+#include <data_bridge/transport/iserial_port.hpp>
+
+class SerialPort : public ISerialPort {
+
+public:
+    SerialPort();
+    ~SerialPort();
+
+    // Prevent copying (Serial ports are unique resources)
+    SerialPort(const SerialPort&) = delete;
+    SerialPort& operator=(const SerialPort&) = delete;
+
+    bool open(const std::string& port_name, int baud_rate) override;
+    void close() override;
+    
+    int write(const std::vector<uint8_t>& data) override;
+    int read(uint8_t* buffer, size_t size) override;
+
+private:
+    // The "Pimpl" - This struct is defined only in the .cpp files
+    struct Impl;
+    std::unique_ptr<Impl> pimpl;
+};

package/deps/src/CMakeLists.txt

@@ -0,0 +1,18 @@
+add_library(data_bridge STATIC 
+    protocol/crc16.cpp
+)
+
+# Platform specific sources
+if(WIN32)
+    target_sources(data_bridge PRIVATE transport/platform/windows/windows_serial.cpp)
+else()
+    target_sources(data_bridge PRIVATE transport/platform/linux/linux_serial.cpp)
+endif()
+
+target_include_directories(data_bridge PUBLIC 
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+# Export the library name for other subdirectories
+set(DATA_BRIDGE_LIB data_bridge PARENT_SCOPE)

package/deps/src/protocol/crc16.cpp

@@ -0,0 +1,19 @@
+#include <data_bridge/protocol/crc16.hpp>
+
+uint16_t crc16_ccitt(const uint8_t* data, size_t len) {
+    uint16_t crc = 0xFFFF;
+
+    for (size_t i = 0; i < len; ++i) {
+        crc ^= static_cast<uint16_t>(data[i]) << 8;
+
+        for (int bit = 0; bit < 8; ++bit) {
+            if (crc & 0x8000)
+                crc = (crc << 1) ^ 0x1021;
+            else
+                crc <<= 1;
+        }
+    }
+
+    return crc;
+}
+

package/deps/src/protocol/packet.cpp

@@ -0,0 +1 @@
+#include "protocol/packet.hpp"

package/deps/src/transport/platform/linux/linux_serial.cpp

@@ -0,0 +1,53 @@
+#include <data_bridge/transport/serial_port.hpp>
+#include <fcntl.h>
+#include <termios.h>
+#include <unistd.h>
+
+struct SerialPort::Impl {
+    int fd = -1;
+};
+
+SerialPort::SerialPort() : pimpl(std::make_unique<Impl>()) {}
+SerialPort::~SerialPort() { close(); }
+
+bool SerialPort::open(const std::string& port, int baud) {
+    pimpl->fd = ::open(port.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
+    if (pimpl->fd == -1) return false;
+
+    // Clear O_NDELAY to make it blocking (uses VTIME)
+    fcntl(pimpl->fd, F_SETFL, 0);
+
+    struct termios tty;
+    if (tcgetattr(pimpl->fd, &tty) != 0) return false;
+
+    cfsetospeed(&tty, B115200);
+    cfsetispeed(&tty, B115200);
+
+    // RAW MODE - Essential for binary/JSON data
+    cfmakeraw(&tty);
+    tty.c_cflag |= (CLOCAL | CREAD);
+    
+    // Explicitly disable flow control just in case cfmakeraw doesn't (it should)
+    tty.c_cflag &= ~CRTSCTS;
+
+    tty.c_cc[VMIN]  = 0;  // Non-blocking
+    tty.c_cc[VTIME] = 1;  // 0.1 second timeout (faster polling)
+
+    tcflush(pimpl->fd, TCIOFLUSH); // Flush on open to clear old buffer garbage
+    return tcsetattr(pimpl->fd, TCSANOW, &tty) == 0;
+}
+
+int SerialPort::write(const std::vector<uint8_t>& data) {
+    int written = ::write(pimpl->fd, data.data(), data.size());
+    // Note: tcdrain() removed - it blocks indefinitely on PTYs (used for testing)
+    // For real serial ports, the write() is sufficient as our protocol handles ACKs
+    return written;
+}
+
+int SerialPort::read(uint8_t* buffer, size_t size) {
+    return ::read(pimpl->fd, buffer, size);
+}
+
+void SerialPort::close() {
+    if (pimpl->fd != -1) { ::close(pimpl->fd); pimpl->fd = -1; }
+}

package/deps/src/transport/platform/windows/windows_serial.cpp

@@ -0,0 +1,51 @@
+#include <data_bridge/transport/serial_port.hpp>
+#include <windows.h>
+
+struct SerialPort::Impl {
+    HANDLE hSerial = INVALID_HANDLE_VALUE;
+};
+
+SerialPort::SerialPort() : pimpl(std::make_unique<Impl>()) {}
+SerialPort::~SerialPort() { close(); }
+
+bool SerialPort::open(const std::string& port, int baud) {
+    pimpl->hSerial = CreateFileA(port.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+    if (pimpl->hSerial == INVALID_HANDLE_VALUE) return false;
+
+    DCB dcb = {0};
+    dcb.DCBlength = sizeof(dcb);
+    GetCommState(pimpl->hSerial, &dcb);
+    dcb.BaudRate = CBR_115200;
+    dcb.ByteSize = 8;
+    dcb.StopBits = ONESTOPBIT;
+    dcb.Parity   = NOPARITY;
+    SetCommState(pimpl->hSerial, &dcb);
+
+    // TIMEOUTS - Prevents the app from freezing
+    COMMTIMEOUTS timeouts = { 0 };
+    timeouts.ReadIntervalTimeout = 50;
+    timeouts.ReadTotalTimeoutConstant = 50;
+    timeouts.ReadTotalTimeoutMultiplier = 10;
+    SetCommTimeouts(pimpl->hSerial, &timeouts);
+
+    return true;
+}
+
+int SerialPort::write(const std::vector<uint8_t>& data) {
+    DWORD written;
+    WriteFile(pimpl->hSerial, data.data(), (DWORD)data.size(), &written, NULL);
+    return (int)written;
+}
+
+int SerialPort::read(uint8_t* buffer, size_t size) {
+    DWORD read;
+    if (!ReadFile(pimpl->hSerial, buffer, (DWORD)size, &read, NULL)) return -1;
+    return (int)read;
+}
+
+void SerialPort::close() {
+    if (pimpl->hSerial != INVALID_HANDLE_VALUE) {
+        CloseHandle(pimpl->hSerial);
+        pimpl->hSerial = INVALID_HANDLE_VALUE;
+    }
+}

package/dist/index.d.mts

@@ -1,5 +1,45 @@
 import { EventEmitter } from 'events';
 
+interface DataBridgeOptions {
+    baudRate?: number;
+    maxRetries?: number;
+    ackTimeoutMs?: number;
+    fragmentSize?: number;
+}
+/**
+ * ReliableDataBridge
+ *
+ * Implements Stop-and-Wait ARQ with fragmentation/reassembly.
+ * Mirrors the Python bindings.wrapper.DataBridge logic.
+ */
+declare class ReliableDataBridge extends EventEmitter {
+    private serial;
+    private reassembler;
+    private isOpen_;
+    private options;
+    private seqId;
+    private rxBuffer;
+    private pendingAcks;
+    constructor(options?: DataBridgeOptions);
+    static open(port: string, baudOrOptions?: number | DataBridgeOptions, cb?: (data: Buffer) => void): Promise<ReliableDataBridge>;
+    open(port: string, baud?: number): Promise<boolean>;
+    close(): Promise<void>;
+    get isOpen(): boolean;
+    send(data: string | Buffer): Promise<void>;
+    private sendWithRetry;
+    private onData;
+}
+
+interface SerialPort {
+    open(port: string, baud: number, callback: (data: Buffer) => void): boolean;
+    write(data: Buffer): number;
+    close(): boolean;
+    isOpen(): boolean;
+}
+declare const SerialPort: {
+    new (): SerialPort;
+};
+
 /**
  * ResilientDataBridge - Connection-resilient wrapper
  *
@@ -74,75 +114,4 @@ declare class ResilientDataBridge extends EventEmitter {
     emit<K extends keyof ResilientEvents>(event: K, ...args: Parameters<ResilientEvents[K]>): boolean;
 }
 
-/**
- * Data Bridge - Guaranteed Reliable Serial Communication
- *
- * TypeScript wrapper for the native Node-API addon.
- * Provides a clean, async-friendly API for Electron applications.
- */
-
-interface DataBridgeOptions {
-    baudRate?: number;
-}
-interface DataBridgeEvents {
-    data: (data: Buffer) => void;
-    error: (error: Error) => void;
-    close: () => void;
-}
-/**
- * DataBridge provides guaranteed reliable serial communication.
- *
- * Features:
- * - Automatic retransmission on packet loss
- * - CRC32 integrity checking
- * - COBS framing for robust delimitation
- * - Fragmentation for large messages
- *
- * @example
- * ```typescript
- * const bridge = await DataBridge.open('/dev/ttyUSB0');
- *
- * bridge.on('data', (data) => {
- *   console.log('Received:', data.toString());
- * });
- *
- * await bridge.send('Hello, World!');
- * await bridge.close();
- * ```
- */
-declare class DataBridge extends EventEmitter {
-    private native;
-    private _isOpen;
-    private constructor();
-    /**
-     * Open a serial port with guaranteed reliable communication.
-     *
-     * @param port - Serial port path (e.g., '/dev/ttyUSB0' or 'COM3')
-     * @param options - Configuration options
-     * @returns Promise resolving to a DataBridge instance
-     */
-    static open(port: string, options?: DataBridgeOptions): Promise<DataBridge>;
-    /**
-     * Send data with guaranteed delivery.
-     *
-     * The data will be fragmented if necessary, checksummed, and
-     * retransmitted until acknowledged by the receiver.
-     *
-     * @param data - Data to send (Buffer or string)
-     * @returns Promise resolving when data is acknowledged
-     */
-    send(data: Buffer | string): Promise<void>;
-    /**
-     * Close the serial port.
-     */
-    close(): Promise<void>;
-    /**
-     * Check if the port is currently open.
-     */
-    get isOpen(): boolean;
-    on<K extends keyof DataBridgeEvents>(event: K, listener: DataBridgeEvents[K]): this;
-    once<K extends keyof DataBridgeEvents>(event: K, listener: DataBridgeEvents[K]): this;
-    emit<K extends keyof DataBridgeEvents>(event: K, ...args: Parameters<DataBridgeEvents[K]>): boolean;
-}
-
-export { DataBridge, type DataBridgeEvents, type DataBridgeOptions, ResilientDataBridge, type ResilientEvents, type ResilientOptions, DataBridge as default };
+export { ReliableDataBridge as DataBridge, type DataBridgeOptions, SerialPort as RawSerialPort, ResilientDataBridge, type ResilientEvents, type ResilientOptions };