@mega-yfue/eufy-sdk 0.2.0-beta.20 → 0.2.0-beta.21

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

@@ -71,9 +71,34 @@ export declare class MegaApiError extends Error {
  * device-list params carry the same `{param_type, param_value, update_time}` and are not owner-gated.
  */
 export declare const OWNER_ONLY_CODE = 20004;
-/** Thrown when a persisted/expired session is rejected (401). Re-login to recover. */
+/**
+ * Thrown when a persisted/expired session is rejected (401). Re-login to recover.
+ *
+ * It carries the rate the client has already worked out for replacing a rejected token, because the
+ * rejection is where that rate stops being the client's alone: a login driven from here spends the same
+ * session the client's own recovery would have, and repeated logins are what makes an account start
+ * demanding captchas. {@link retryAfterMs} is how long the next replacement is barred for, and
+ * {@link contended} whether this rejection landed inside that bar — the shape repeated displacement has.
+ */
 export declare class SessionExpiredError extends Error {
-    constructor(message: string);
+    /**
+     * How long the next session replacement is barred for, in milliseconds; `0` when nothing bars one now.
+     *
+     * The remainder of the client's own hold-off, which doubles per consecutive replacement and is capped —
+     * and which every replacement extends, whether the client spent it or a login made on this error did.
+     */
+    readonly retryAfterMs: number;
+    /**
+     * 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.
+     */
+    readonly contended: boolean;
+    constructor(message: string, opts?: {
+        retryAfterMs?: number;
+        contended?: boolean;
+    });
 }
 /**
  * eufy cloud gateway error codes — the numeric `code` carried in a response envelope alongside the
@@ -223,9 +248,11 @@ export declare class MegaHttpClient {
     private loggingIn;
     /** The one in-flight re-login every call rejected on the same dead token waits on. */
     private reauthAttempt?;
-    /** Replacements since the held session last proved stable, and when the last one ran — see {@link recoveryDue}. */
+    /** Replacements since the held session last proved stable, and when the last one ran — see {@link holdOffRemainingMs}. */
     private recoveries;
     private lastRecoveryAt;
+    /** A token of ours has been rejected and not yet replaced — see {@link noteTokenReplacement}. */
+    private rejectedTokenPending;
     constructor(cfg: MegaClientConfig);
     /**
      * Install the session the store holds, if it holds a usable one: the token + its bound ECDH key, skipping
@@ -500,6 +527,26 @@ export declare class MegaHttpClient {
      * and a caller is told the honest reason instead of being served a fight.
      */
     private recoveryDue;
+    /**
+     * How much longer a token replacement must wait, in milliseconds; `0` when one may run now.
+     *
+     * The wait doubles per consecutive replacement and is capped, and it is what {@link recoveryDue} gates
+     * this client's own recovery on — and what {@link SessionExpiredError.retryAfterMs} hands a host that
+     * drives its own. One function so the two cannot disagree about the rate, which they would have to for
+     * a host to be told it may retry while this client is still holding off.
+     */
+    private holdOffRemainingMs;
+    /**
+     * Count one token replacement against the hold-off, and clear the rejection it answered.
+     *
+     * Every replacement passes through here, wherever it was spent from: {@link recoverRejectedSession}, and
+     * a {@link login} that follows a rejection this client surfaced. A hold-off that counted only its own
+     * would be no bound at all — the wait would sit at its first value however many sessions had been spent,
+     * and {@link SessionExpiredError.retryAfterMs} would report a minute while logins ran every few seconds.
+     * Which of the two counted a given replacement is the flag: the recovery path clears it before logging
+     * in, so the login cannot count the same one again.
+     */
+    private noteTokenReplacement;
     /**
      * Note that the held session is working. A replacement that keeps serving calls for long enough is not
      * contention, so the hold-off is forgotten and the next genuine expiry recovers immediately.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.2.0-beta.20",
+  "version": "0.2.0-beta.21",
   "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",