@mega-yfue/eufy-sdk 0.3.0-beta.2 → 0.3.0-beta.4

package/dist/transport/http/mega-client.d.ts

@@ -91,8 +91,9 @@ export declare class SessionExpiredError extends Error {
     /**
      * Whether this rejection landed inside that bar — a token replaced recently and rejected again since.
      *
-     * It says the session is being DISPLACED rather than expiring: something else is signing in on this
-     * account, and replacing the token again only trades one login for another.
+     * That is the shape displacement by another client signed in on this account has, where replacing the
+     * token again only trades one login for another. It is not proof of one, since a cloud refusing to
+     * re-issue the session looks the same.
      */
     readonly contended: boolean;
     constructor(message: string, opts?: {
@@ -212,6 +213,8 @@ export declare class MegaHttpClient {
     private sessionKey?;
     /** Per-host ECDH session keys for non-mega gateways (e.g. eufylife) keyed by host. */
     private readonly sessionKeys;
+    /** The in-flight key exchanges, by host and the token they carry — see {@link ensureSessionKey}. */
+    private readonly keyExchanges;
     /**
      * The held credential. `userId` is the login reply's `ap_cloud_user_id` where it has one — the Anker
      * Passport cloud's id — while `accountUserId` is the eufy account's own `user_id`.
@@ -318,6 +321,8 @@ export declare class MegaHttpClient {
      * so it MUST be reused (don't re-exchange after login).
      */
     ensureSessionKey(targetHost?: string): Promise<SessionEntry>;
+    /** One key exchange against `host`, installed as that host's key. */
+    private exchangeSessionKey;
     /**
      * Signed + encrypted POST. Content-type auto-falls-back (text/plain ↔ json).
      *
@@ -523,8 +528,8 @@ export declare class MegaHttpClient {
      * like the same device — and the cloud keeps one session per device. Each finds its token rejected, replaces
      * it, and evicts the other: an unbounded login war, silent, and repeated logins are exactly what makes an
      * account start demanding captchas. The first replacement is immediate, because a token displaced once is
-     * the ordinary case; a second one soon after is evidence of contention rather than expiry, so the wait grows
-     * and a caller is told the honest reason instead of being served a fight.
+     * the ordinary case; a second one soon after has the shape of contention rather than expiry, so the wait grows
+     * and a caller is told what was seen instead of being served a fight.
      */
     private recoveryDue;
     /**

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.2",
+  "version": "0.3.0-beta.4",
   "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",