@mega-yfue/eufy-sdk 0.3.0-beta.1 → 0.3.0-beta.3

package/dist/index.js

@@ -5813,6 +5813,7 @@ var LIGHT_SWITCH_JSON_TYPES = /* @__PURE__ */ new Set([
   DeviceType.CAMERA_4G_S330
 ]);
 var LIGHT_SWITCH_INT_STRING_TYPES = /* @__PURE__ */ new Set([
+  DeviceType.FLOODLIGHT_CAMERA_8423,
   DeviceType.INDOOR_OUTDOOR_CAMERA_1080P_NO_LIGHT,
   DeviceType.INDOOR_OUTDOOR_CAMERA_2K,
   DeviceType.INDOOR_OUTDOOR_CAMERA_1080P,
@@ -15140,6 +15141,8 @@ var LIVE_START_ACK_DEADLINE_MS = 3e3;
 var SEQUENCE_LOOKBACK = 32768;
 var STALE_RETRANSMIT_DEPTH = 1024;
 var PUNCH_PROBE_SOCKETS = 7;
+var REORDER_WAIT_MS = 250;
+var REORDER_MAX_DATAGRAMS = 128;
 var MAX_TRACED_DATAGRAM_GAPS = 8;
 var CMD_SET_PAYLOAD = 1350;
 var CMD_NOTIFY_PAYLOAD = 1351;
@@ -15209,9 +15212,10 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   selfHost;
   /** In-flight multi-datagram frame per data channel (see onData). */
   pendingByDataType = /* @__PURE__ */ new Map();
-  /** Last datagram sequence number seen per dataType — used to detect a lost/reordered datagram
-   * mid-frame and drop the (now unrecoverable) partial frame instead of splicing wrong bytes. */
+  /** Last delivered datagram sequence number per data type. */
   lastSeqByType = /* @__PURE__ */ new Map();
+  /** Held datagrams and their active gap timer, grouped by data type. */
+  reorderByType = /* @__PURE__ */ new Map();
   tracedDatagramGaps = 0;
   level1Key;
   /** Negotiated 32-byte level-2/gateway key (AES-256-GCM). Set via setLevel2Key once known. */
@@ -16466,8 +16470,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * Acknowledge and reassemble one DATA datagram, sequenced independently per data type.
    *
    * The device numbers each data type's datagrams in its own 16-bit space and repeats what it thinks was
-   * lost, so a datagram that does not advance the sequence — a duplicate, or one already superseded — is a
-   * retransmission of something already reassembled: it is acknowledged, then ignored. Distance is measured
+   * lost. A repeat of something already delivered is acknowledged, then ignored. Distance is measured
    * modulo the sequence space and read as backwards beyond {@link SEQUENCE_LOOKBACK}, which is what lets the
    * numbering wrap without the next datagram looking like a jump of nearly a full space.
    *
@@ -16477,9 +16480,13 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * numbering and the half-assembled frame goes — because ignoring it would freeze the mark, and every
    * datagram of the new numbering would then be read as behind it too, for as long as it took to climb back.
    *
-   * Only a forward gap means a datagram is genuinely missing. A logical frame's payload spans datagrams that
-   * carry no header of their own, so the bytes cannot be reassembled around the hole: whatever was pending
-   * for that data type is discarded, and the frame is rebuilt from the next header.
+   * A forward gap means a datagram has not arrived YET, which is not the same as lost. The device repeats
+   * unacknowledged datagrams, so successors are held for a bounded wait and delivered strictly in sequence
+   * if the missing one arrives. A logical frame's payload spans datagrams that carry no header of their
+   * own, so reassembling around a hole is impossible; waiting for it is what keeps the frame whole.
+   *
+   * Only once {@link REORDER_WAIT_MS} passes, or {@link REORDER_MAX_DATAGRAMS} pile up, is the datagram
+   * treated as lost: a pending frame is discarded and delivery resumes from the earliest held datagram.
    */
   onData(msg, addr) {
     const dataTypeBuffer = msg.subarray(4, 6);
@@ -16490,18 +16497,98 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     const advance = prevSeq === void 0 ? 1 : seqNo - prevSeq & 65535;
     if (advance === 0)
       return;
-    const restarted = advance > SEQUENCE_LOOKBACK && 65536 - advance > STALE_RETRANSMIT_DEPTH;
-    if (advance > SEQUENCE_LOOKBACK && !restarted)
-      return;
-    this.lastSeqByType.set(dataType, seqNo);
-    if ((advance > 1 || restarted) && this.pendingByDataType.has(dataType)) {
-      if (this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS) {
-        this.trace({ phase: restarted ? "sequence-restart" : "datagram-gap", dataType });
-      }
+    if (advance > SEQUENCE_LOOKBACK) {
+      if (65536 - advance <= STALE_RETRANSMIT_DEPTH)
+        return;
+      if (this.pendingByDataType.has(dataType) && this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS)
+        this.trace({ phase: "sequence-restart", dataType });
+      this.clearReorderTimer(dataType);
+      this.reorderByType.delete(dataType);
       this.pendingByDataType.delete(dataType);
+      this.lastSeqByType.set(dataType, seqNo);
+      this.reassemble(dataType, msg.subarray(8));
+      return;
+    }
+    if (advance === 1) {
+      this.lastSeqByType.set(dataType, seqNo);
+      this.reassemble(dataType, msg.subarray(8));
+      this.drainReorder(dataType);
+      return;
+    }
+    this.holdForRetransmit(dataType, seqNo, msg.subarray(8));
+  }
+  /** Hold a datagram that arrived past a hole, and arm the wait for the missing one to be repeated. */
+  holdForRetransmit(dataType, seqNo, body) {
+    let reorder = this.reorderByType.get(dataType);
+    if (!reorder) {
+      reorder = { held: /* @__PURE__ */ new Map() };
+      this.reorderByType.set(dataType, reorder);
+    }
+    if (!reorder.held.has(seqNo))
+      reorder.held.set(seqNo, body);
+    if (reorder.held.size > REORDER_MAX_DATAGRAMS) {
+      this.abandonHole(dataType);
+      return;
+    }
+    this.armReorderTimer(dataType);
+  }
+  /** Start a full wait for the current hole, leaving an existing wait undisturbed. */
+  armReorderTimer(dataType) {
+    const reorder = this.reorderByType.get(dataType);
+    if (!reorder?.held.size || reorder.timer)
+      return;
+    const timer = setTimeout(() => {
+      reorder.timer = void 0;
+      this.abandonHole(dataType);
+    }, REORDER_WAIT_MS);
+    timer.unref?.();
+    reorder.timer = timer;
+  }
+  /** Deliver held datagrams that now follow directly on from the last one delivered. */
+  drainReorder(dataType) {
+    const reorder = this.reorderByType.get(dataType);
+    if (!reorder?.held.size)
+      return;
+    this.clearReorderTimer(dataType);
+    for (; ; ) {
+      const next = this.lastSeqByType.get(dataType) + 1 & 65535;
+      const body = reorder.held.get(next);
+      if (body === void 0)
+        break;
+      reorder.held.delete(next);
+      this.lastSeqByType.set(dataType, next);
+      this.reassemble(dataType, body);
     }
+    if (reorder.held.size)
+      this.armReorderTimer(dataType);
+    else
+      this.reorderByType.delete(dataType);
+  }
+  /**
+   * The missing datagram was not repeated in time: report the gap, drop the frame it belonged to, and
+   * resume from the earliest datagram still held so the stream keeps moving.
+   */
+  abandonHole(dataType) {
+    const held = this.reorderByType.get(dataType).held;
+    if (this.pendingByDataType.has(dataType) && this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS)
+      this.trace({ phase: "datagram-gap", dataType });
+    this.pendingByDataType.delete(dataType);
+    const last = this.lastSeqByType.get(dataType);
+    const earliest = [...held.keys()].sort((a, b) => (a - last & 65535) - (b - last & 65535))[0];
+    this.lastSeqByType.set(dataType, earliest - 1 & 65535);
+    this.drainReorder(dataType);
+  }
+  clearReorderTimer(dataType) {
+    const reorder = this.reorderByType.get(dataType);
+    if (!reorder?.timer)
+      return;
+    clearTimeout(reorder.timer);
+    reorder.timer = void 0;
+  }
+  /** Reassemble one in-sequence datagram body into logical frames. */
+  reassemble(dataType, datagramBody) {
     const pending = this.pendingByDataType.get(dataType);
-    let body = pending ? Buffer.concat([pending.buf, msg.subarray(8)]) : msg.subarray(8);
+    let body = pending ? Buffer.concat([pending.buf, datagramBody]) : datagramBody;
     const carryHeader = pending?.header;
     this.pendingByDataType.delete(dataType);
     if (carryHeader) {
@@ -16532,6 +16619,9 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * completed either.
    */
   resetInboundSequencing() {
+    for (const dataType of this.reorderByType.keys())
+      this.clearReorderTimer(dataType);
+    this.reorderByType.clear();
     this.lastSeqByType.clear();
     this.pendingByDataType.clear();
     this.tracedDatagramGaps = 0;