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

package/dist/transport/p2p/p2p-session.d.ts

@@ -136,9 +136,10 @@ export declare class P2PSession extends EventEmitter {
     private selfHost?;
     /** In-flight multi-datagram frame per data channel (see onData). */
     private readonly pendingByDataType;
-    /** 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. */
     private readonly lastSeqByType;
+    /** Held datagrams and their active gap timer, grouped by data type. */
+    private readonly reorderByType;
     private tracedDatagramGaps;
     private readonly level1Key;
     /** Negotiated 32-byte level-2/gateway key (AES-256-GCM). Set via setLevel2Key once known. */
@@ -611,8 +612,7 @@ export declare class P2PSession extends EventEmitter {
      * 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.
      *
@@ -622,11 +622,29 @@ export declare class P2PSession extends EventEmitter {
      * 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.
      */
     private onData;
+    /** Hold a datagram that arrived past a hole, and arm the wait for the missing one to be repeated. */
+    private holdForRetransmit;
+    /** Start a full wait for the current hole, leaving an existing wait undisturbed. */
+    private armReorderTimer;
+    /** Deliver held datagrams that now follow directly on from the last one delivered. */
+    private drainReorder;
+    /**
+     * 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.
+     */
+    private abandonHole;
+    private clearReorderTimer;
+    /** Reassemble one in-sequence datagram body into logical frames. */
+    private reassemble;
     /**
      * Forget where each data type's sequence numbering had reached, and drop any half-reassembled frame.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.3.0-beta.1",
+  "version": "0.3.0-beta.3",
   "description": "One typed TypeScript client for the Anker eufy v6 cloud — capability-driven devices, realtime events over P2P/MQTT/push, and live media",
   "license": "Apache-2.0",
   "author": "mega-yfue",