@technoculture/data-bridge 0.1.1 → 0.1.2

package/lib/reliable.ts

@@ -0,0 +1,234 @@
+
+import { EventEmitter } from 'events';
+import { SerialPort, Packet, Reassembler, Frame } from './native';
+
+export 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.
+ */
+export class ReliableDataBridge extends EventEmitter {
+  private serial: SerialPort;
+  private reassembler: Reassembler;
+  private isOpen_ = false;
+
+  // Config
+  private options: Required<DataBridgeOptions>;
+
+  // State
+  private seqId = 0;
+  private 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)
+  private pendingAcks = new Map<number, (fragId: number) => void>();
+
+  constructor(options: DataBridgeOptions = {}) {
+    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: string, baudOrOptions?: number | DataBridgeOptions, cb?: (data: Buffer) => void): Promise<ReliableDataBridge> {
+    let opts: DataBridgeOptions = {};
+    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: string, baud?: number): Promise<boolean> {
+    if (this.isOpen_) return true;
+
+    // Backward compatibility: override baud from options if provided
+    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 (): Promise<void> {
+    if (this.isOpen_)
+    {
+      this.serial.close();
+      this.isOpen_ = false;
+      this.emit('close');
+    }
+  }
+
+  get isOpen (): boolean {
+    return this.isOpen_;
+  }
+
+  async send (data: string | Buffer): Promise<void> {
+    if (!this.isOpen_) throw new Error("Port not open");
+
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+
+    // Fragment
+    const fragments: Buffer[] = [];
+    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);
+    }
+  }
+
+  private async sendWithRetry (packet: Buffer, seq: number, fragId: number): Promise<void> {
+    let retries = 0;
+
+    while (retries <= this.options.maxRetries)
+    {
+      // Prepare waiter
+      const ackPromise = new Promise<void>((resolve, reject) => {
+        const handler = (ackedFragId: number) => {
+          if (ackedFragId === fragId) resolve();
+        };
+        this.pendingAcks.set(seq, handler);
+
+        // Timeout
+        setTimeout(() => {
+          if (this.pendingAcks.has(seq))
+          {
+            this.pendingAcks.delete(seq);
+            reject(new Error("Timeout"));
+          }
+        }, this.options.ackTimeoutMs);
+      });
+
+      // Send
+      this.serial.write(packet);
+
+      try
+      {
+        await ackPromise;
+        return; // Success
+      } catch (e)
+      {
+        retries++;
+        // console.log(`[Reliable] Retry ${retries} for seq=${seq} frag=${fragId}`);
+      }
+    }
+
+    throw new Error(`Send failed after ${this.options.maxRetries} retries`);
+  }
+
+  private onData (chunk: Buffer) {
+    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;
+        }
+        // Else we consumed some garbage, continue loop with remaining
+        this.rxBuffer = Buffer.from(remaining);
+        continue;
+      }
+
+      // Valid frame
+      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);
+        }
+      }
+    }
+  }
+}

package/lib/resilient.ts

@@ -38,6 +38,7 @@ interface QueuedMessage {
 }
 
 export class ResilientDataBridge extends EventEmitter {
+  // Use DataBridge type from index (which is reliable now)
   private bridge: DataBridge | null = null;
   private port: string;
   private options: Required<ResilientOptions>;
@@ -53,6 +54,9 @@ export 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 ?? 1000,
       maxReconnectDelay: options.maxReconnectDelay ?? 30000,
@@ -75,9 +79,11 @@ export class ResilientDataBridge extends EventEmitter {
   private async connect (): Promise<void> {
     try
     {
-      this.bridge = await DataBridge.open(this.port, {
-        baudRate: this.options.baudRate,
-      });
+      // Pass full options to reliable bridge
+      this.bridge = new DataBridge(this.options);
+
+      // Open using just the port (options passed in constructor)
+      await this.bridge.open(this.port);
 
       this.isConnected = true;
       this.reconnectAttempt = 0;
@@ -88,8 +94,23 @@ export class ResilientDataBridge extends EventEmitter {
       });
 
       // Handle errors and detect disconnection
+      // Note: ReliableDataBridge might not emit error on single failure (it retries), 
+      // but it will if retries exhausted or port error.
       this.bridge.on('error', (err) => {
         this.emit('error', err);
+        // If error is fatal (port closed/lost), handle disconnect
+        // ReliableDataBridge throws/emits error if max retries reached. 
+        // We need to assume that might mean broken link or just timeouts?
+        // Actually SerialPort wrapper might throw/emit if underlying handle dies.
+        // For simplicity, treat any error as triggers for potential reconnection logic or check isOpen
+        if (!this.bridge?.isOpen)
+        {
+          this.handleDisconnect();
+        }
+      });
+
+      // Check if closed
+      this.bridge.on('close', () => {
         this.handleDisconnect();
       });
 
@@ -117,7 +138,7 @@ export class ResilientDataBridge extends EventEmitter {
     if (!this.isConnected) return;
 
     this.isConnected = false;
-    this.bridge = null;
+    this.bridge = null; // Clean up old instance
     this.emit('disconnect');
 
     if (this.shouldReconnect && this.options.reconnect)
@@ -166,7 +187,7 @@ export class ResilientDataBridge extends EventEmitter {
   async send (data: Buffer | string): Promise<void> {
     const buffer = typeof data === 'string' ? Buffer.from(data) : data;
 
-    if (this.isConnected && this.bridge)
+    if (this.isConnected && this.bridge && this.bridge.isOpen)
     {
       // Connected - send immediately
       try
@@ -174,7 +195,9 @@ export class ResilientDataBridge extends EventEmitter {
         await this.bridge.send(buffer);
       } catch (err)
       {
-        // Send failed - queue it and handle disconnect
+        // Send failed (retries exhausted or port error)
+        // Queue it and trigger reconnect check
+        this.handleDisconnect(); // Force reconnect cycle logic
         return this.queueMessage(buffer);
       }
     } else
@@ -274,3 +297,4 @@ export class ResilientDataBridge extends EventEmitter {
 }
 
 export default ResilientDataBridge;
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technoculture/data-bridge",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Guaranteed reliable serial communication for Node.js and Electron",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -18,13 +18,15 @@
     "build:native": "cmake-js compile",
     "build:ts": "tsup lib/index.ts --format cjs,esm --dts",
     "prebuild": "cmake-js compile -O prebuilds/$(node -p \"process.platform + '-' + process.arch\")",
+    "prepack": "node scripts/copy_deps.js && npm run build:ts",
     "prepublishOnly": "npm run build:ts",
     "test": "vitest run",
-    "clean": "cmake-js clean && rm -rf dist prebuilds"
+    "clean": "cmake-js clean && rm -rf dist prebuilds deps"
   },
   "files": [
     "dist",
-    "prebuilds",
+    "prebuilds/**/*.node",
+    "deps",
     "src",
     "lib",
     "CMakeLists.txt"
@@ -60,7 +62,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/aspect-labs/data-bridge"
+    "url": "https://github.com/technoculture/data-bridge"
   },
   "keywords": [
     "serial",