@technoculture/data-bridge 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -5,13 +5,188 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// lib/index.ts
-import { EventEmitter as EventEmitter2 } from "events";
+// lib/reliable.ts
+import { EventEmitter } from "events";
+
+// lib/native.ts
 import path from "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(path.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 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
-import { EventEmitter } from "events";
-var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter {
+import { EventEmitter as EventEmitter2 } from "events";
+var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter2 {
+  // Use DataBridge type from index (which is reliable now)
   bridge = null;
   port;
   options;
@@ -26,6 +201,9 @@ var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter {
     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,
@@ -45,9 +223,8 @@ var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter {
   }
   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) => {
@@ -55,6 +232,11 @@ var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter {
       });
       this.bridge.on("error", (err) => {
         this.emit("error", err);
+        if (!this.bridge?.isOpen) {
+          this.handleDisconnect();
+        }
+      });
+      this.bridge.on("close", () => {
         this.handleDisconnect();
       });
       if (this.isReconnecting) {
@@ -110,10 +292,11 @@ var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter {
    */
   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 {
@@ -186,100 +369,8 @@ var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter {
     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(path.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 EventEmitter2 {
-  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;
 export {
-  DataBridge,
-  ResilientDataBridge,
-  index_default as default
+  ReliableDataBridge as DataBridge,
+  SerialPort as RawSerialPort,
+  ResilientDataBridge
 };

package/lib/index.ts

@@ -1,3 +1,4 @@
+
 /**
  * Data Bridge - Guaranteed Reliable Serial Communication
  * 
@@ -5,167 +6,18 @@
  * Provides a clean, async-friendly API for Electron applications.
  */
 
-import { EventEmitter } from 'events';
-import path from 'path';
-
-// Load native addon - works in both ESM and CJS
-let addon: NativeAddon;
-
-function loadAddon (): NativeAddon {
-  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
-    {
-      // Use require for native addons (works in both ESM and CJS)
-      return require(path.join(__dirname, p));
-    } catch
-    {
-      continue;
-    }
-  }
-
-  throw new Error('Failed to load native addon. Run `npm run build` first.');
-}
-
-addon = loadAddon();
-
-interface NativeAddon {
-  DataBridge: new () => NativeDataBridge;
-}
-
-interface NativeDataBridge {
-  open (port: string, baud: number, callback?: (data: Buffer) => void): Promise<boolean>;
-  send (data: Buffer | string): Promise<number>;
-  close (): boolean;
-  isOpen (): boolean;
-}
-
-export interface DataBridgeOptions {
-  baudRate?: number;
-}
-
-export 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();
- * ```
- */
-export class DataBridge extends EventEmitter {
-  private native: NativeDataBridge;
-  private _isOpen = false;
-
-  private 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: string, options: DataBridgeOptions = {}): Promise<DataBridge> {
-    const instance = new DataBridge();
-    const baud = options.baudRate ?? 115200;
-
-    const onData = (data: Buffer) => {
-      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: Buffer | string): Promise<void> {
-    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 (): Promise<void> {
-    if (this._isOpen)
-    {
-      this.native.close();
-      this._isOpen = false;
-      this.emit('close');
-    }
-  }
-
-  /**
-   * Check if the port is currently open.
-   */
-  get isOpen (): boolean {
-    return this._isOpen && this.native.isOpen();
-  }
-
-  // Type-safe event emitter methods
-  on<K extends keyof DataBridgeEvents> (event: K, listener: DataBridgeEvents[K]): this {
-    return super.on(event, listener);
-  }
-
-  once<K extends keyof DataBridgeEvents> (event: K, listener: DataBridgeEvents[K]): this {
-    return super.once(event, listener);
-  }
+import { ReliableDataBridge, DataBridgeOptions } from './reliable';
+import { SerialPort } from './native';
 
-  emit<K extends keyof DataBridgeEvents> (event: K, ...args: Parameters<DataBridgeEvents[K]>): boolean {
-    return super.emit(event, ...args);
-  }
-}
+// Export the Reliable implementation as the default DataBridge
+export { ReliableDataBridge as DataBridge };
+export { DataBridgeOptions };
 
-export default DataBridge;
+// Export Raw SerialPort for advanced users
+export { SerialPort as RawSerialPort };
 
-// Re-export resilient wrapper
+// Export Resilient wrapper (connection resilience)
+// Note: ResilientDataBridge wraps DataBridge. 
+// If DataBridge is now Reliable, ResilientDataBridge will hold a ReliableDataBridge.
+// This gives us Connection Resilience + Data Reliability.
 export { ResilientDataBridge, ResilientOptions, ResilientEvents } from './resilient';

package/lib/native.ts

@@ -0,0 +1,71 @@
+
+import path from 'path';
+
+// Load native addon
+function loadAddon (): any {
+  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(path.join(__dirname, p));
+    } catch
+    {
+      continue;
+    }
+  }
+  throw new Error('Failed to load native addon. Run `npm run build` first.');
+}
+
+const addon = loadAddon();
+
+export interface SerialPort {
+  open (port: string, baud: number, callback: (data: Buffer) => void): boolean;
+  write (data: Buffer): number;
+  close (): boolean;
+  isOpen (): boolean;
+}
+
+export const SerialPort: {
+  new(): SerialPort;
+} = addon.SerialPort;
+
+export interface Frame {
+  valid: boolean;
+  header: {
+    type: number;
+    seq_id: number;
+    fragment_id: number;
+    total_frags: number;
+    payload_len: number;
+    crc32: number;
+  };
+  payload: Buffer;
+}
+
+export interface PacketHelper {
+  serialize (type: number, seq: number, payload: string | Buffer, frag_id?: number, total_frags?: number): Buffer;
+  deserialize (buffer: Buffer): { frame: Frame; remaining: Buffer; };
+  TYPE_DATA: number;
+  TYPE_ACK: number;
+  TYPE_NACK: number;
+  TYPE_SYN: number;
+}
+
+export const Packet: PacketHelper = addon.Packet;
+
+export interface Reassembler {
+  processFragment (frame: Frame): boolean;
+  isComplete (frame: Frame): boolean;
+  getData (): Buffer;
+  isDuplicate (frame: Frame): boolean;
+  getBufferedSize (): number;
+}
+
+export const Reassembler: {
+  new(): Reassembler;
+} = addon.Reassembler;