@technoculture/data-bridge 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -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 };

package/dist/index.js

@@ -30,17 +30,194 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/index.ts
 var index_exports = {};
 __export(index_exports, {
-  DataBridge: () => DataBridge,
-  ResilientDataBridge: () => ResilientDataBridge,
-  default: () => index_default
+  DataBridge: () => ReliableDataBridge,
+  RawSerialPort: () => SerialPort,
+  ResilientDataBridge: () => ResilientDataBridge
 });
 module.exports = __toCommonJS(index_exports);
-var import_events2 = require("events");
+
+// lib/reliable.ts
+var import_events = require("events");
+
+// lib/native.ts
 var import_path = __toESM(require("path"));
+function loadAddon() {
+  const possiblePaths = [
+    `../prebuilds/${process.platform}-${process.arch}/data_bridge_node.node`,
+    "../build/Release/data_bridge_node.node"
+  ];
+  for (const p of possiblePaths) {
+    try {
+      return require(import_path.default.join(__dirname, p));
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Failed to load native addon. Run `npm run build` first.");
+}
+var addon = loadAddon();
+var SerialPort = addon.SerialPort;
+var Packet = addon.Packet;
+var Reassembler = addon.Reassembler;
+
+// lib/reliable.ts
+var ReliableDataBridge = class _ReliableDataBridge extends import_events.EventEmitter {
+  serial;
+  reassembler;
+  isOpen_ = false;
+  // Config
+  options;
+  // State
+  seqId = 0;
+  rxBuffer = Buffer.alloc(0);
+  // ARQ State
+  // We only process one send at a time (Stop-and-Wait)
+  // Map of seqId -> { resolve, reject } (though we only have one really)
+  pendingAcks = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    super();
+    this.serial = new SerialPort();
+    this.reassembler = new Reassembler();
+    this.options = {
+      baudRate: options.baudRate ?? 115200,
+      maxRetries: options.maxRetries ?? 10,
+      ackTimeoutMs: options.ackTimeoutMs ?? 500,
+      fragmentSize: options.fragmentSize ?? 200
+    };
+  }
+  static async open(port, baudOrOptions, cb) {
+    let opts = {};
+    if (typeof baudOrOptions === "number") {
+      opts.baudRate = baudOrOptions;
+    } else if (baudOrOptions) {
+      opts = baudOrOptions;
+    }
+    const bridge = new _ReliableDataBridge(opts);
+    if (cb) bridge.on("data", cb);
+    await bridge.open(port);
+    return bridge;
+  }
+  async open(port, baud) {
+    if (this.isOpen_) return true;
+    const baudRate = baud ?? this.options.baudRate;
+    const success = this.serial.open(port, baudRate, (data) => {
+      this.onData(data);
+    });
+    if (success) {
+      this.isOpen_ = true;
+      return true;
+    }
+    throw new Error(`Failed to open ${port}`);
+  }
+  async close() {
+    if (this.isOpen_) {
+      this.serial.close();
+      this.isOpen_ = false;
+      this.emit("close");
+    }
+  }
+  get isOpen() {
+    return this.isOpen_;
+  }
+  async send(data) {
+    if (!this.isOpen_) throw new Error("Port not open");
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    const fragments = [];
+    for (let i = 0; i < buf.length; i += this.options.fragmentSize) {
+      fragments.push(buf.subarray(i, i + this.options.fragmentSize));
+    }
+    const totalFrags = fragments.length;
+    const seq = this.seqId;
+    this.seqId = (this.seqId + 1) % 256;
+    for (let fragId = 0; fragId < totalFrags; fragId++) {
+      const payload = fragments[fragId];
+      const packet = Packet.serialize(
+        Packet.TYPE_DATA,
+        seq,
+        payload,
+        fragId,
+        totalFrags
+      );
+      await this.sendWithRetry(packet, seq, fragId);
+    }
+  }
+  async sendWithRetry(packet, seq, fragId) {
+    let retries = 0;
+    while (retries <= this.options.maxRetries) {
+      const ackPromise = new Promise((resolve, reject) => {
+        const handler = (ackedFragId) => {
+          if (ackedFragId === fragId) resolve();
+        };
+        this.pendingAcks.set(seq, handler);
+        setTimeout(() => {
+          if (this.pendingAcks.has(seq)) {
+            this.pendingAcks.delete(seq);
+            reject(new Error("Timeout"));
+          }
+        }, this.options.ackTimeoutMs);
+      });
+      this.serial.write(packet);
+      try {
+        await ackPromise;
+        return;
+      } catch (e) {
+        retries++;
+      }
+    }
+    throw new Error(`Send failed after ${this.options.maxRetries} retries`);
+  }
+  onData(chunk) {
+    this.rxBuffer = Buffer.concat([this.rxBuffer, chunk]);
+    while (true) {
+      const { frame, remaining } = Packet.deserialize(this.rxBuffer);
+      if (!frame.valid) {
+        if (remaining.length === this.rxBuffer.length) {
+          break;
+        }
+        this.rxBuffer = Buffer.from(remaining);
+        continue;
+      }
+      this.rxBuffer = Buffer.from(remaining);
+      if (frame.header.type === Packet.TYPE_ACK) {
+        const seq = frame.header.seq_id;
+        const frag = frame.header.fragment_id;
+        if (this.pendingAcks.has(seq)) {
+          this.pendingAcks.get(seq)(frag);
+        }
+      } else if (frame.header.type === Packet.TYPE_DATA) {
+        let shouldAck = false;
+        if (this.reassembler.processFragment(frame)) {
+          shouldAck = true;
+          if (this.reassembler.isComplete(frame)) {
+            try {
+              const data = this.reassembler.getData();
+              this.emit("data", data);
+            } catch (e) {
+              console.error("Error in data emission:", e);
+            }
+          }
+        } else if (this.reassembler.isDuplicate(frame)) {
+          shouldAck = true;
+        }
+        if (shouldAck) {
+          const ackParams = Packet.serialize(
+            Packet.TYPE_ACK,
+            frame.header.seq_id,
+            Buffer.alloc(0),
+            frame.header.fragment_id,
+            frame.header.total_frags
+          );
+          this.serial.write(ackParams);
+        }
+      }
+    }
+  }
+};
 
 // lib/resilient.ts
-var import_events = require("events");
-var ResilientDataBridge = class _ResilientDataBridge extends import_events.EventEmitter {
+var import_events2 = require("events");
+var ResilientDataBridge = class _ResilientDataBridge extends import_events2.EventEmitter {
+  // Use DataBridge type from index (which is reliable now)
   bridge = null;
   port;
   options;
@@ -55,6 +232,9 @@ var ResilientDataBridge = class _ResilientDataBridge extends import_events.Event
     this.port = port;
     this.options = {
       baudRate: options.baudRate ?? 115200,
+      maxRetries: options.maxRetries ?? 10,
+      ackTimeoutMs: options.ackTimeoutMs ?? 500,
+      fragmentSize: options.fragmentSize ?? 200,
       reconnect: options.reconnect ?? true,
       reconnectDelay: options.reconnectDelay ?? 1e3,
       maxReconnectDelay: options.maxReconnectDelay ?? 3e4,
@@ -74,9 +254,8 @@ var ResilientDataBridge = class _ResilientDataBridge extends import_events.Event
   }
   async connect() {
     try {
-      this.bridge = await DataBridge.open(this.port, {
-        baudRate: this.options.baudRate
-      });
+      this.bridge = new ReliableDataBridge(this.options);
+      await this.bridge.open(this.port);
       this.isConnected = true;
       this.reconnectAttempt = 0;
       this.bridge.on("data", (data) => {
@@ -84,6 +263,11 @@ var ResilientDataBridge = class _ResilientDataBridge extends import_events.Event
       });
       this.bridge.on("error", (err) => {
         this.emit("error", err);
+        if (!this.bridge?.isOpen) {
+          this.handleDisconnect();
+        }
+      });
+      this.bridge.on("close", () => {
         this.handleDisconnect();
       });
       if (this.isReconnecting) {
@@ -139,10 +323,11 @@ var ResilientDataBridge = class _ResilientDataBridge extends import_events.Event
    */
   async send(data) {
     const buffer = typeof data === "string" ? Buffer.from(data) : data;
-    if (this.isConnected && this.bridge) {
+    if (this.isConnected && this.bridge && this.bridge.isOpen) {
       try {
         await this.bridge.send(buffer);
       } catch (err) {
+        this.handleDisconnect();
         return this.queueMessage(buffer);
       }
     } else {
@@ -215,100 +400,9 @@ var ResilientDataBridge = class _ResilientDataBridge extends import_events.Event
     return super.emit(event, ...args);
   }
 };
-
-// lib/index.ts
-var addon;
-function loadAddon() {
-  const possiblePaths = [
-    // Prebuilt binaries
-    `../prebuilds/${process.platform}-${process.arch}/data_bridge_node.node`,
-    // Local build
-    "../build/Release/data_bridge_node.node"
-  ];
-  for (const p of possiblePaths) {
-    try {
-      return require(import_path.default.join(__dirname, p));
-    } catch {
-      continue;
-    }
-  }
-  throw new Error("Failed to load native addon. Run `npm run build` first.");
-}
-addon = loadAddon();
-var DataBridge = class _DataBridge extends import_events2.EventEmitter {
-  native;
-  _isOpen = false;
-  constructor() {
-    super();
-    this.native = new addon.DataBridge();
-  }
-  /**
-   * 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 async open(port, options = {}) {
-    const instance = new _DataBridge();
-    const baud = options.baudRate ?? 115200;
-    const onData = (data) => {
-      instance.emit("data", data);
-    };
-    try {
-      await instance.native.open(port, baud, onData);
-      instance._isOpen = true;
-      return instance;
-    } catch (err) {
-      throw new Error(`Failed to open ${port}: ${err instanceof Error ? err.message : err}`);
-    }
-  }
-  /**
-   * 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
-   */
-  async send(data) {
-    if (!this._isOpen) {
-      throw new Error("Port not open");
-    }
-    const buffer = typeof data === "string" ? Buffer.from(data) : data;
-    await this.native.send(buffer);
-  }
-  /**
-   * Close the serial port.
-   */
-  async close() {
-    if (this._isOpen) {
-      this.native.close();
-      this._isOpen = false;
-      this.emit("close");
-    }
-  }
-  /**
-   * Check if the port is currently open.
-   */
-  get isOpen() {
-    return this._isOpen && this.native.isOpen();
-  }
-  // Type-safe event emitter methods
-  on(event, listener) {
-    return super.on(event, listener);
-  }
-  once(event, listener) {
-    return super.once(event, listener);
-  }
-  emit(event, ...args) {
-    return super.emit(event, ...args);
-  }
-};
-var index_default = DataBridge;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DataBridge,
+  RawSerialPort,
   ResilientDataBridge
 });