@mega-yfue/eufy-sdk 0.6.0-beta.15 → 0.6.0-beta.17

package/dist/client/eufy-mega.d.ts

@@ -54,6 +54,12 @@ export declare class EufyMega extends EventEmitter {
     /** Shared in-flight/settled `startMqtt()` promise PER SCOPE — so realtime bring-up and an on-demand
      * publish await the SAME fully-connected transport instead of racing (and never open two). */
     private readonly mqttReady;
+    /**
+     * Serials {@link subscribeMqttDevices} has subscribed or is subscribing, per transport, so a later pass
+     * subscribes only devices that transport has not carried yet. Keyed by transport, so a new connection
+     * starts empty.
+     */
+    private readonly mqttSubscribed;
     /** Device list/record/capability resolution + the frame→caps cache. */
     private readonly registry;
     private pushClient?;
@@ -632,6 +638,9 @@ export declare class EufyMega extends EventEmitter {
      * A device with changed params is re-resolved by {@link widenCapabilities} once per pass, however many
      * of its params moved, since each re-resolution is a cloud param-list read.
      *
+     * Then brings the secure-MQTT plane up to the roster ({@link syncMqttRoster}): the startup bring-up
+     * sized it from the roster at login, which is empty when the cloud was unreachable then.
+     *
      * Then re-reads every Tuya clean-line robot from the Tuya cloud ({@link readTuyaDevices}): its state
      * is not in the cloud record this pass diffs and no live channel carries it, so the poll is where it
      * stays fresh. That read runs after the `try`, not inside it, so a cloud error on the list diff does
@@ -818,11 +827,20 @@ export declare class EufyMega extends EventEmitter {
     /**
      * Subscribe the devices on one credential scope; a failing subscribe is reported, not fatal (one
      * unreachable device must not stop the rest of the roster from coming up).
+     * A device is recorded in that transport's {@link mqttSubscribed} entry before its subscribe is awaited,
+     * whatever the outcome, so a pass running alongside or after skips it: each device is attempted once
+     * per transport.
      *
      * A Tuya clean-line device (`eufy_home_tuya`) is not subscribed: its state lives on the Tuya cloud,
      * and the broker refuses its `eufy_home` topics on every credential.
      */
     private subscribeMqttDevices;
+    /**
+     * Start every credential scope the roster now needs and has no transport for, and subscribe the
+     * devices that joined a scope already up — each scope's failure reported, not thrown. A no-op once
+     * the realtime generation is superseded or was never started.
+     */
+    private syncMqttRoster;
     /**
      * Send whatever a device's capabilities want sent once its realtime channel is up — for a line whose
      * state is pushed on change with no heartbeat, the request that makes its state readable before the

package/dist/index.js

@@ -16226,7 +16226,7 @@ import { EventEmitter as EventEmitter2 } from "node:events";
 import dgram from "node:dgram";
 import { resolve4 } from "node:dns/promises";
 import { isIP as isIP2 } from "node:net";
-import { constants as constants2, createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv4, generateKeyPairSync, privateDecrypt as privateDecrypt2, randomBytes as randomBytes4 } from "node:crypto";
+import { constants as constants2, createCipheriv as createCipheriv4, createECDH as createECDH3, createDecipheriv as createDecipheriv4, generateKeyPairSync, privateDecrypt as privateDecrypt2, randomBytes as randomBytes4 } from "node:crypto";
 
 // dist/transport/p2p/live-trace.js
 var LIVE_TRACE_MESSAGE = "[live] start trace";
@@ -16453,6 +16453,13 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   level2Seq = 0;
   rsaPrivateKey;
   rsaModulusHex;
+  /** The P-256 pair an attached camera's media start offers; see {@link mediaEccPrivateKey}. */
+  mediaEcc;
+  /**
+   * Per attached channel, the media-key type its latest start offered on this connection, or that last answered,
+   * and whether a keyframe has answered it. See {@link attachedStartKey} and {@link settleAttachedKey}.
+   */
+  attachedStartKeys = /* @__PURE__ */ new Map();
   /**
    * Whether a level-2 key negotiation kicked off by a GATEWAYINFO reply is in flight. Cleared when it
    * settles, so a later reply — the answer to {@link repromptLevel2Key} — negotiates again.
@@ -16778,7 +16785,15 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     const [level, outcome] = granted > 0 ? ["debug", ` (granted ${granted})`] : ["warn", " (request refused)"];
     this.logger[level](`[p2p] ${this.cfg.stationSn} UDP receive buffer below the ${RECEIVE_BUFFER_BYTES} bytes requested` + outcome + `; live video can lose keyframes. Raise the OS limit (net.core.rmem_max on Linux, kern.ipc.maxsockbuf on BSD) to at least ${RECEIVE_BUFFER_BYTES}.`);
   }
-  /** Open the socket and start the lookup → hole-punch handshake. */
+  /**
+   * Open the socket and start the lookup → hole-punch handshake.
+   *
+   * A socket closed or failing while binding never invokes its bind callback, so the bind wait also
+   * settles on the socket's `close` and `error`. On `close`, a connect whose session was closed meanwhile
+   * returns without starting the handshake, so it never sends a lookup or arms a timer on a closed
+   * session. On `error`, connect closes the session and rejects with {@link StationUnreachableError}
+   * carrying the bind error as its `cause`.
+   */
   async connect() {
     if (this.connecting || this.connected)
       return;
@@ -16786,6 +16801,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.closed = false;
     this.connectionGeneration += 1;
     this.ackedRounds = void 0;
+    this.attachedStartKeys.clear();
     this.resetInboundSequencing();
     if (!this.level2KeyServes("set-payload")) {
       this.level2Pending = this.cfg.resolveCipherKey !== void 0;
@@ -16798,8 +16814,12 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.socket = socket;
     socket.on("message", (msg, rinfo) => this.onMessage(msg, rinfo, socket));
     socket.on("error", (e) => this.emit("error", e));
-    await new Promise((resolve2) => {
+    const generation = this.connectionGeneration;
+    await new Promise((resolve2, reject) => {
+      socket.once("close", resolve2);
+      socket.once("error", reject);
       socket.bind(() => {
+        socket.off("error", reject);
         try {
           socket.setBroadcast(true);
         } catch {
@@ -16807,7 +16827,12 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
         this.requestReceiveBuffer(socket);
         resolve2();
       });
+    }).catch(async (error) => {
+      await this.close();
+      throw new StationUnreachableError(this.cfg.stationSn, 0, { cause: error });
     });
+    if (generation !== this.connectionGeneration)
+      return;
     void _P2PSession.detectLocalIp().then((host) => {
       if (host && !this.closed)
         this.selfHost = host;
@@ -16815,7 +16840,6 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     const { dskKey, cloudAddresses } = this.cfg;
     this.cloudLookup = dskKey && cloudAddresses?.length ? { key: dskKey, addresses: cloudAddresses } : void 0;
     if (this.cloudLookup && cloudAddresses) {
-      const generation = this.connectionGeneration;
       void resolveLookupServers(cloudAddresses).then((addresses) => {
         if (this.cloudLookup && !this.closed && generation === this.connectionGeneration)
           this.cloudLookup.addresses = addresses;
@@ -17183,13 +17207,15 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   startLiveMedia(channel = STATION_CHANNEL3, accountId = "", homeBaseAttached = false, opts) {
     if (homeBaseAttached) {
       this.tracedDatagramGaps = 0;
+      const key = this.connectAddress && this.level2Key ? this.attachedStartKey(channel) : void 0;
       this.trace({
         phase: "media-command",
         topology: "attached",
         action: "start",
-        level2: !!this.level2Key
+        level2: !!this.level2Key,
+        key
       });
-      this.sendMediaPayloadLevel2(CMD_START_REALTIME_MEDIA, channel, accountId, {});
+      this.sendMediaPayloadLevel2(CMD_START_REALTIME_MEDIA, channel, accountId, {}, key);
       return;
     }
     const want = this.level2Key ? "l2" : this.sendsInTheClear() ? "clear" : "l1";
@@ -17689,8 +17715,12 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * Send a CMD_SET_PAYLOAD(1350) wrapping `{account_id, cmd:<subCmd>, mChannel, mValue3:<subCmd>,
    * payload}`, encrypted level-2 (AES-256-GCM, signCode 8) — the app's media-control path. The
    * camera is selected by `mChannel` (= the device's `device_channel`) AND the frame-header channel.
+   * A start (HomeBase-controlled camera path, the V6 app's media-start envelope) also carries an
+   * `accountId` inside its payload and the media key `key` offers (see {@link attachedStartKey}). A start
+   * offering the P-256 point labels itself `ClientOS: "IOS"`, as every simple attached start in the app
+   * captures that carry that key form does; the RSA start keeps `"Android"`.
    */
-  sendMediaPayloadLevel2(subCmd, channel, accountId, payload) {
+  sendMediaPayloadLevel2(subCmd, channel, accountId, payload, key) {
     if (!this.connectAddress || !this.level2Key) {
       this.trace({
         phase: "media-command-unsent",
@@ -17700,11 +17730,11 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     }
     const isStart = subCmd === CMD_START_REALTIME_MEDIA;
     const innerPayload = isStart ? {
-      ClientOS: "Android",
+      ClientOS: key === "ecc" ? "IOS" : "Android",
       accountId,
       camera_type: 0,
       entrytype: 0,
-      key: this.rsaModulus(),
+      key: key === "ecc" ? this.mediaEccPair().point : this.rsaModulus(),
       streamtype: 2,
       ...payload
     } : payload;
@@ -17779,6 +17809,70 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       return void 0;
     }
   }
+  /**
+   * The media-key type the next attached start sent on `channel` offers, recorded as offered: ECC, the current
+   * app's form, for the first start this connection sends there; RSA for every start after one that no keyframe
+   * answered before it was re-issued; and, once a keyframe has answered, the type that opened it, until
+   * {@link settleAttachedKey} records another. Only an opened keyframe answers: frames no key opens, and deltas,
+   * do not. A re-issue is a full restart on an attached camera, so a camera that cannot read the point is asked
+   * with RSA, the start every station answers, and is not asked with the point again while that goes unanswered.
+   * A stream decoding with the session's pair reads either answer. A station without {@link mediaEccPrivateKey}
+   * is offered RSA only. A start that cannot be sent offers nothing and records nothing.
+   */
+  attachedStartKey(channel) {
+    if (!this.mediaEccPrivateKey)
+      return "rsa";
+    const last = this.attachedStartKeys.get(channel);
+    if (last?.answered)
+      return last.kind;
+    const kind = last ? "rsa" : "ecc";
+    this.attachedStartKeys.set(channel, { kind, answered: false });
+    return kind;
+  }
+  /**
+   * Record how a keyframe of `channel` was opened, which answers the starts there. A keyframe opened under a
+   * key type is an answer of that type, whichever type the latest start offered: a station can serve the
+   * P-256 start after the RSA re-issue went out. A plaintext keyframe
+   * answering an unanswered P-256 offer is a camera that did not use the point, and the next start there offers
+   * RSA; once a P-256 answer has been opened it changes nothing, and answering RSA, it settles RSA. Answers
+   * whether a new start is needed. A channel no attached start has offered a key on is left as it is.
+   */
+  settleAttachedKey(channel, opened) {
+    const last = this.attachedStartKeys.get(channel);
+    if (!last)
+      return false;
+    if (opened === "plain" && last.kind === "ecc")
+      return !last.answered;
+    this.attachedStartKeys.set(channel, { kind: opened === "ecc" ? "ecc" : "rsa", answered: true });
+    return false;
+  }
+  /**
+   * The 32-byte P-256 private scalar paired with the point an attached camera's media start offers as `key`.
+   * A camera answering that start wraps each keyframe's AES-256-GCM media key in an ECIES envelope for this
+   * key ({@link VideoFrameDecoder}). Generated once per session, like the RSA pair.
+   *
+   * `undefined` unless the station is a HomeBase 3 (`T8030`): the app's P-256 start and the device runs
+   * that answered it were both observed on that station only.
+   */
+  get mediaEccPrivateKey() {
+    return this.cfg.stationSn.startsWith("T8030") ? this.mediaEccPair().privateKey : void 0;
+  }
+  /**
+   * The session's P-256 pair: the private scalar as 32 bytes, and the public point as 128 hex characters,
+   * `x ‖ y` without the uncompressed-point prefix, the form the current app's attached-camera start carries in
+   * `key`. `ECDH.getPrivateKey()` drops a scalar's leading zero bytes, so the scalar is padded back to 32.
+   */
+  mediaEccPair() {
+    if (!this.mediaEcc) {
+      const ecdh = createECDH3("prime256v1");
+      ecdh.generateKeys();
+      this.mediaEcc = {
+        privateKey: Buffer.from(ecdh.getPrivateKey("hex").padStart(64, "0"), "hex"),
+        point: ecdh.getPublicKey().subarray(1).toString("hex")
+      };
+    }
+    return this.mediaEcc;
+  }
   /**
    * The RSA-1024 public-key modulus (128-byte hex) the station uses to wrap the per-stream media
    * key. Lazily generates a keypair; `rsaPrivateKey` decrypts the media key the station returns.
@@ -18849,8 +18943,9 @@ var AccessUnitAssembler = class {
     this.onDropped?.({ carried: open2.carried, chunks: open2.chunks.length, count: this.droppedUnits });
   }
 };
+var SPLIT_UNIT_STAMP_SPREAD_MS = 100;
 function sameUnit(open2, next) {
-  return next.timestamp === open2.timestamp && next.sequence === open2.sequence;
+  return next.sequence === open2.sequence && next.timestamp - open2.timestamp >>> 0 <= SPLIT_UNIT_STAMP_SPREAD_MS;
 }
 function beginsAccessUnit(body) {
   if (body.length < 4 || body[0] !== 0 || body[1] !== 0)
@@ -19184,10 +19279,29 @@ function h265Geometry(sps) {
 }
 
 // dist/transport/p2p/audio-frame.js
+import { createDecipheriv as createDecipheriv7 } from "node:crypto";
 var CMD_AUDIO_FRAME2 = 1301;
 var AUDIO_HEADER_LEN = 16;
 var AUDIO_TYPE_OFFSET = 5;
 var AUDIO_CODECS = { 0: "aac-lc", 2: "g711a", 7: "aac-eld" };
+var AUDIO_NONCE_START = 32;
+var AUDIO_BODY_START = 44;
+function isSealedAudio(frame) {
+  return frame.length >= AUDIO_BODY_START && frame.length >= AUDIO_BODY_START + frame.readUInt32LE(0);
+}
+function openSealedAudio(frame, mediaKey) {
+  if (!isSealedAudio(frame))
+    return void 0;
+  try {
+    const decipher = createDecipheriv7("aes-256-gcm", mediaKey, frame.subarray(AUDIO_NONCE_START, AUDIO_BODY_START));
+    decipher.setAAD(VIDEO_GCM_AAD);
+    decipher.setAuthTag(frame.subarray(AUDIO_HEADER_LEN, AUDIO_NONCE_START));
+    const body = frame.subarray(AUDIO_BODY_START, AUDIO_BODY_START + frame.readUInt32LE(0));
+    return Buffer.concat([decipher.update(body), decipher.final()]);
+  } catch {
+    return void 0;
+  }
+}
 
 // dist/transport/p2p/live-stream.js
 var CMD_VIDEO_FRAME2 = 1300;
@@ -19219,6 +19333,8 @@ var LiveStream = class extends EventEmitter3 {
   tracedFirstVideoUnit = false;
   tracedFirstKeyframe = false;
   tracedDecodeFailures = 0;
+  /** How the frame that opened the latest access unit was read; see {@link settleStartKey}. */
+  unitOpenedBy = "plain";
   tracedFirstForeignFrame = false;
   stallTimer;
   /**
@@ -19241,8 +19357,9 @@ var LiveStream = class extends EventEmitter3 {
     this.channel = opts.channel ?? STATION_CHANNEL3;
     if (opts.homeBaseAttached && opts.channel !== void 0)
       this.mediaChannel = opts.channel;
-    if (opts.eccPrivateKey)
-      this.decoder = new VideoFrameDecoder(opts.eccPrivateKey);
+    const eccPrivateKey = opts.eccPrivateKey ?? (opts.homeBaseAttached ? session.mediaEccPrivateKey : void 0);
+    if (eccPrivateKey)
+      this.decoder = new VideoFrameDecoder(eccPrivateKey);
   }
   /** Emit a live trace under its session's handle and the channel this stream pulls. */
   trace(trace) {
@@ -19403,8 +19520,10 @@ var LiveStream = class extends EventEmitter3 {
             this.tracedFirstKeyframe = true;
             this.trace({ phase: "first-keyframe" });
           }
-          if (unit.keyframe)
+          if (unit.keyframe) {
             this.lastCodec = sniffAnnexbCodec(unit.data) ?? this.lastCodec;
+            this.settleStartKey();
+          }
           this.settleKeepalive();
           this.emit("video", {
             sourceTimestamp: unit.sourceTimestamp,
@@ -19416,8 +19535,8 @@ var LiveStream = class extends EventEmitter3 {
           });
         }
       } else if (f.commandId === CMD_AUDIO_FRAME2) {
-        const audio = f.data.length > AUDIO_HEADER_LEN ? f.data.subarray(AUDIO_HEADER_LEN) : f.data;
-        if (audio.length) {
+        const audio = this.audioPayload(f.data);
+        if (audio?.length) {
           const codecId = f.data.length > AUDIO_TYPE_OFFSET ? f.data.readUInt8(AUDIO_TYPE_OFFSET) : void 0;
           const codec = codecId === void 0 ? void 0 : AUDIO_CODECS[codecId];
           if (!codec) {
@@ -19468,19 +19587,54 @@ var LiveStream = class extends EventEmitter3 {
     return false;
   }
   /**
-   * The Annex-B payload of a frame that starts an access unit. The session decodes it when it can (it
-   * holds the RSA private key, and handles the plaintext form); the legacy header-strip and the ECIES
-   * {@link VideoFrameDecoder} are the fallbacks for an E2E camera.
+   * The Annex-B payload of a frame that starts an access unit. The authenticated ECIES/GCM
+   * {@link VideoFrameDecoder} goes first: its HMAC and GCM checks fail closed on a frame not sealed for its
+   * key. The session's RSA path cannot: on Node ≥ 24.5, PKCS#1 v1.5 decryption of a key not wrapped for it
+   * returns pseudo-random bytes instead of throwing (implicit rejection), which would decode an ECC
+   * keyframe into noise. The session's decode, which also passes plaintext frames, and the header strip
+   * follow. A payload that opens an access unit records how it was read: by the ECIES path, or otherwise by
+   * its sign code, sealed (`"rsa"`) or in the clear (`"plain"`).
    */
   annexbOf(payload, signCode) {
-    const annexb = this.session.decodeVideoFrame?.(payload, signCode) ?? this.plaintextAnnexB(payload);
-    if (annexb)
-      return annexb;
     const decoded = this.decoder?.decodeFrame(payload)?.h264;
-    if (!decoded && this.tracedDecodeFailures++ < MAX_TRACED_DECODE_FAILURES) {
+    if (decoded) {
+      if (beginsAccessUnit(decoded))
+        this.unitOpenedBy = "ecc";
+      return decoded;
+    }
+    const annexb = this.session.decodeVideoFrame?.(payload, signCode) ?? this.plaintextAnnexB(payload);
+    if (!annexb && this.tracedDecodeFailures++ < MAX_TRACED_DECODE_FAILURES) {
       this.trace({ phase: "video-decode-empty", signCode });
     }
-    return decoded;
+    if (annexb && beginsAccessUnit(annexb))
+      this.unitOpenedBy = signCode > 0 ? "rsa" : "plain";
+    return annexb;
+  }
+  /**
+   * Tell the session how this keyframe was opened, which answers the attached starts on this channel
+   * ({@link P2PSession.settleAttachedKey}), and re-issue the start when the session asks for one: a plaintext
+   * keyframe answering the session's P-256 offer, from a camera that did not use the point, which the next
+   * start asks with RSA. Only a delivered keyframe answers: a frame no key opens, or a continuation without the
+   * frame that opened its unit, delivers nothing.
+   */
+  settleStartKey() {
+    if (!this.session.settleAttachedKey?.(this.channel, this.unitOpenedBy))
+      return;
+    this.logger.debug(`[live ch${this.channel}] plaintext keyframe answered the P-256 offer \u2014 re-starting with RSA`);
+    this.sendStart();
+  }
+  /**
+   * The payload of an audio frame. On a stream with an ECIES decoder, a sealed frame ({@link isSealedAudio}) is
+   * opened under the media key of the latest keyframe, and answers `undefined` when it does not open or arrives
+   * before any keyframe gave a media key, since its bytes are ciphertext. Every other frame is the bytes after
+   * its header.
+   */
+  audioPayload(frame) {
+    if (!this.decoder || !isSealedAudio(frame)) {
+      return frame.length > AUDIO_HEADER_LEN ? frame.subarray(AUDIO_HEADER_LEN) : frame;
+    }
+    const mediaKey = this.decoder.currentMediaKey;
+    return mediaKey ? openSealedAudio(frame, mediaKey) : void 0;
   }
   /**
    * Report an access unit the transport could not complete.
@@ -19770,12 +19924,8 @@ function annexbToJpeg(annexb, spawn2) {
 }
 
 // dist/transport/p2p/recording-download.js
-import { createDecipheriv as createDecipheriv7 } from "node:crypto";
 var RECORDING_DATA_TYPE = 3;
 var VIDEO_HEADER_LEN2 = 22;
-var AUDIO_HEADER_LEN2 = 16;
-var AUDIO_NONCE_START = 32;
-var AUDIO_BODY_START = 44;
 var AUDIO_CODEC_AAC_LC = 0;
 var FINISH_CHANNEL = 0;
 var FIRST_FRAME_WAIT_MS = 2e4;
@@ -19887,16 +20037,6 @@ function receiveRecording(session, request) {
   }
   return { frames, drained };
 }
-function openAudio(key, nonce, tag2, body) {
-  try {
-    const decipher = createDecipheriv7("aes-256-gcm", key, nonce);
-    decipher.setAAD(VIDEO_GCM_AAD);
-    decipher.setAuthTag(tag2);
-    return Buffer.concat([decipher.update(body), decipher.final()]);
-  } catch {
-    return void 0;
-  }
-}
 function decodeRecording(frames, eccPrivateKeyHex) {
   const eccPrivateKey = Buffer.from(eccPrivateKeyHex, "hex");
   if (eccPrivateKey.length !== 32)
@@ -19925,12 +20065,9 @@ function decodeRecording(frames, eccPrivateKeyHex) {
       }
     } else if (commandId === CommandType.CMD_AUDIO_FRAME) {
       const mediaKey = decoder.currentMediaKey;
-      if (!mediaKey || raw.length < AUDIO_BODY_START || raw[5] !== AUDIO_CODEC_AAC_LC)
-        continue;
-      const len = raw.readUInt32LE(0);
-      if (raw.length < AUDIO_BODY_START + len)
+      if (!mediaKey || raw[5] !== AUDIO_CODEC_AAC_LC)
         continue;
-      const aac = openAudio(mediaKey, raw.subarray(AUDIO_NONCE_START, AUDIO_BODY_START), raw.subarray(AUDIO_HEADER_LEN2, AUDIO_NONCE_START), raw.subarray(AUDIO_BODY_START, AUDIO_BODY_START + len));
+      const aac = openSealedAudio(raw, mediaKey);
       if (aac?.length)
         audio.push(aac);
     }
@@ -25243,10 +25380,7 @@ var RtcSession = class extends EventEmitter11 {
         this.emit("error", e instanceof Error ? e : new Error(String(e)));
       });
     });
-    this.signaling.on("close", () => {
-      this.connected = false;
-      this.announceClose();
-    });
+    this.signaling.on("close", () => this.shutdown());
     this.signaling.on("error", (e) => this.emit("error", e));
     this.peer.on("iceCandidate", (c) => this.trickle(toWireCandidate(c)));
     this.peer.on("iceGatheringComplete", () => this.trickle(""));
@@ -29363,6 +29497,12 @@ var EufyMega = class extends EventEmitter14 {
   /** Shared in-flight/settled `startMqtt()` promise PER SCOPE — so realtime bring-up and an on-demand
    * publish await the SAME fully-connected transport instead of racing (and never open two). */
   mqttReady = /* @__PURE__ */ new Map();
+  /**
+   * Serials {@link subscribeMqttDevices} has subscribed or is subscribing, per transport, so a later pass
+   * subscribes only devices that transport has not carried yet. Keyed by transport, so a new connection
+   * starts empty.
+   */
+  mqttSubscribed = /* @__PURE__ */ new WeakMap();
   /** Device list/record/capability resolution + the frame→caps cache. */
   registry;
   pushClient;
@@ -30708,6 +30848,9 @@ var EufyMega = class extends EventEmitter14 {
    * A device with changed params is re-resolved by {@link widenCapabilities} once per pass, however many
    * of its params moved, since each re-resolution is a cloud param-list read.
    *
+   * Then brings the secure-MQTT plane up to the roster ({@link syncMqttRoster}): the startup bring-up
+   * sized it from the roster at login, which is empty when the cloud was unreachable then.
+   *
    * Then re-reads every Tuya clean-line robot from the Tuya cloud ({@link readTuyaDevices}): its state
    * is not in the cloud record this pass diffs and no live channel carries it, so the poll is where it
    * stays fresh. That read runs after the `try`, not inside it, so a cloud error on the list diff does
@@ -30728,6 +30871,7 @@ var EufyMega = class extends EventEmitter14 {
         this.emit("deviceState", this.stateOf(dev));
       for (const sn of new Set(diff.params.map((c) => c.deviceSn)))
         await this.widenCapabilities(sn);
+      await this.syncMqttRoster();
     } catch (e) {
       this.reportError(e);
     }
@@ -31067,12 +31211,21 @@ var EufyMega = class extends EventEmitter14 {
   /**
    * Subscribe the devices on one credential scope; a failing subscribe is reported, not fatal (one
    * unreachable device must not stop the rest of the roster from coming up).
+   * A device is recorded in that transport's {@link mqttSubscribed} entry before its subscribe is awaited,
+   * whatever the outcome, so a pass running alongside or after skips it: each device is attempted once
+   * per transport.
    *
    * A Tuya clean-line device (`eufy_home_tuya`) is not subscribed: its state lives on the Tuya cloud,
    * and the broker refuses its `eufy_home` topics on every credential.
    */
   async subscribeMqttDevices(scope, transport) {
+    let subscribed = this.mqttSubscribed.get(transport);
+    if (!subscribed)
+      this.mqttSubscribed.set(transport, subscribed = /* @__PURE__ */ new Set());
     for (const d of this.getMqttDevices().filter((dev) => !isTuyaVacuum(dev) && mqttScopeFor(dev) === scope)) {
+      if (subscribed.has(d.sn))
+        continue;
+      subscribed.add(d.sn);
       try {
         await transport.subscribeDevice(d);
         await this.sendRealtimeInit(d.sn);
@@ -31081,6 +31234,23 @@ var EufyMega = class extends EventEmitter14 {
       }
     }
   }
+  /**
+   * Start every credential scope the roster now needs and has no transport for, and subscribe the
+   * devices that joined a scope already up — each scope's failure reported, not thrown. A no-op once
+   * the realtime generation is superseded or was never started.
+   */
+  async syncMqttRoster() {
+    if (this.realtimeGeneration?.epoch !== this.realtimeEpoch)
+      return;
+    await Promise.all(this.mqttScopesInUse().map(async (scope) => {
+      const transport = this.transports.get(scope);
+      try {
+        await (transport ? this.subscribeMqttDevices(scope, transport) : this.ensureMqttStarted(scope));
+      } catch (e) {
+        this.reportError(e);
+      }
+    }));
+  }
   /**
    * Send whatever a device's capabilities want sent once its realtime channel is up — for a line whose
    * state is pushed on change with no heartbeat, the request that makes its state readable before the
@@ -32758,6 +32928,7 @@ export {
   aesKey,
   asBool,
   assertNever,
+  beginsAccessUnit,
   bizChannelName,
   buildActions,
   buildAppShapedClientId,