@mega-yfue/eufy-sdk 0.3.0-beta.0 → 0.3.0-beta.10

package/dist/index.js

@@ -1102,8 +1102,9 @@ var SessionExpiredError = class 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.
    */
   contended;
   constructor(message, opts = {}) {
@@ -1149,7 +1150,7 @@ var LoginStatus = {
 var REAUTH_HOLD_OFF_MS = 6e4;
 var REAUTH_HOLD_OFF_CAP_MS = 30 * 6e4;
 var REAUTH_STABLE_MS = 10 * 6e4;
-var CONTENDED_SESSION_HINT = "another client signed in on this account keeps displacing this session \u2014 the cloud holds about one session per account and device identity, so each login ends the other's; where the other client is another SDK install, give each its own openudid";
+var CONTENDED_SESSION_HINT = "the token was rejected again soon after it was last replaced; one possible cause is another client signed in with the same account and device identity, since the cloud holds about one session per pair and each login ends the other's (where that is another SDK install, give each its own openudid)";
 function tokenRejected(code, msg) {
   return code === EufyCloudErrorCode.SESSION_KICKED || /user_id is empty|invalid[^,]*\btoken\b|\btoken\b[^,]*(expired|error|not exist)|kicked|(?:\btoken\b|\bsession\b)[^,]*does not exist|unauthor/i.test(msg ?? "");
 }
@@ -1163,6 +1164,8 @@ var MegaHttpClient = class {
   sessionKey;
   /** Per-host ECDH session keys for non-mega gateways (e.g. eufylife) keyed by host. */
   sessionKeys = /* @__PURE__ */ new Map();
+  /** The in-flight key exchanges, by host and the token they carry — see {@link ensureSessionKey}. */
+  keyExchanges = /* @__PURE__ */ new Map();
   /**
    * 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`.
@@ -1384,6 +1387,20 @@ var MegaHttpClient = class {
         return cached2;
     }
     const host = isEufylife ? targetHost : this.bootstrapDomain ?? `app-openapi-${this.region}.eufy.com`;
+    const flight = `${host}
+${this.auth_?.authToken ?? ""}`;
+    const joining = this.keyExchanges.get(flight);
+    if (joining)
+      return joining;
+    const exchange = this.exchangeSessionKey(host, isEufylife).finally(() => {
+      if (this.keyExchanges.get(flight) === exchange)
+        this.keyExchanges.delete(flight);
+    });
+    this.keyExchanges.set(flight, exchange);
+    return exchange;
+  }
+  /** One key exchange against `host`, installed as that host's key. */
+  async exchangeSessionKey(host, isEufylife) {
     const kxPath = isEufylife ? "/v3/openapi/oauth/key/exchange" : "/openapi/oauth/key/exchange";
     const prep = prepareKeyExchange(isEufylife ? EUFYLIFE_LOCAL_KEY_HEX : void 0);
     const res = await this.httpPost(`https://${host}${kxPath}`, { client_public_key: prep.encryptedClientPublicKey }, {
@@ -1399,7 +1416,7 @@ var MegaHttpClient = class {
     }
     const entry = finishKeyExchange(prep, env.data.server_public_key);
     if (isEufylife)
-      this.sessionKeys.set(targetHost, entry);
+      this.sessionKeys.set(host, entry);
     else
       this.sessionKey = entry;
     return entry;
@@ -1470,9 +1487,10 @@ var MegaHttpClient = class {
     const identityError = authed && (last?.code === EufyCloudErrorCode.IDENTITY_KEY_STALE || /get identity error|identity error/i.test(last?.msg ?? ""));
     if (identityError && !retry.identity && this.auth_) {
       this.logger.debug("[mega] identity error \u2192 re-exchanging session key and retrying");
-      if (host.includes(".eufylife.com"))
-        this.sessionKeys.delete(host);
-      else
+      if (host.includes(".eufylife.com")) {
+        if (this.sessionKeys.get(host) === entry)
+          this.sessionKeys.delete(host);
+      } else if (this.sessionKey === entry)
         this.sessionKey = void 0;
       try {
         await this.ensureSessionKey(host);
@@ -1832,14 +1850,14 @@ var MegaHttpClient = class {
    * 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.
    */
   recoveryDue() {
     const remaining = this.holdOffRemainingMs();
     if (remaining === 0)
       return true;
-    this.logger.warn(`[mega] token rejected ${Math.round((Date.now() - this.lastRecoveryAt) / 1e3)}s after the last replacement \u2014 holding off ${Math.round(remaining / 1e3)}s more. ${CONTENDED_SESSION_HINT}`);
+    this.logger.warn(`[mega] holding off ${Math.round(remaining / 1e3)}s more before replacing the token again (last replaced ${Math.round((Date.now() - this.lastRecoveryAt) / 1e3)}s ago): ${CONTENDED_SESSION_HINT}`);
     return false;
   }
   /**
@@ -2113,6 +2131,13 @@ function isNotAuthorized(err) {
 var SecureMqtt = class extends EventEmitter {
   kind = "smqtt";
   client;
+  /**
+   * The in-flight or established connect. A client ID is exclusive at the broker, so a second mqtt.js
+   * client under the same ID evicts the first, which reconnects and evicts it back, forever; `connect()`
+   * therefore hands a later caller this same attempt instead of opening a rival. Cleared when the
+   * attempt fails and on `disconnect()`, so a caller can still retry or deliberately reconnect.
+   */
+  connecting;
   o;
   logger;
   constructor(opts) {
@@ -2123,11 +2148,19 @@ var SecureMqtt = class extends EventEmitter {
   get id() {
     return this.o.clientId ?? this.o.credentials.thing_name ?? "";
   }
+  /** Connect, joining the attempt in `connecting` when one is already opening or open. */
+  async connect() {
+    this.connecting ??= this.open().catch((error) => {
+      this.connecting = void 0;
+      throw error;
+    });
+    return await this.connecting;
+  }
   /**
    * Open the broker connection, resolving once it is established. Pinned to a broker instance's IP, or
    * to the plain hostname; only the former needs its own TLS shape, see `./bare-ip-tls.ts`.
    */
-  async connect() {
+  async open() {
     const mqtt = await loadMqtt();
     const c = this.o.credentials;
     const port = c.endpoint_port ?? 8883;
@@ -2255,6 +2288,7 @@ var SecureMqtt = class extends EventEmitter {
     await this.client.publishAsync(topic, body, { qos: opts.qos ?? 1 });
   }
   async disconnect() {
+    this.connecting = void 0;
     await this.client?.endAsync(true);
     this.client = void 0;
   }
@@ -4292,7 +4326,10 @@ function decodePowerSource(raw) {
 function recordSetting(param, value, ctx) {
   return setStationScalar(param, value, ctx.channel);
 }
-var MAINS_CAMERA_MODELS = ["T8425", "T8419", "T8410"];
+var MAINS_CAMERA_MODELS = ["T8425", "T8419", "T8410", "T84A1"];
+function cameraPowerTier(model, capabilities) {
+  return capabilities.has("battery") && notMainsCamera({ model }) ? "battery" : "wired";
+}
 var notMainsCamera = (ctx) => {
   const model = (ctx.model ?? "").toUpperCase();
   return !MAINS_CAMERA_MODELS.some((prefix) => model.startsWith(prefix));
@@ -5202,7 +5239,7 @@ function statusLedCommand(on, ctx) {
   return setScalar(CAMERA_CMD.DEV_LED_SWITCH, on ? 1 : 0, ctx, "int-string");
 }
 function poweredOf(ctx) {
-  return ctx.capabilities?.has("battery") ? "battery" : "wired";
+  return cameraPowerTier(ctx.model, ctx.capabilities ?? /* @__PURE__ */ new Set());
 }
 function enablementReflection(on, ctx) {
   const alias = CAMERA_MEMBERS.enabled.readAliases[0].paramType;
@@ -5813,6 +5850,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,
@@ -10851,6 +10889,8 @@ var MODEL_REGISTRY = {
   T8400: { codec: "camera", caps: ["arming"], name: "Indoor Cam" },
   T8410: { codec: "camera", caps: ["arming"], name: "Indoor Cam Pan & Tilt" },
   T8442: { codec: "camera", caps: ["arming"], name: "Indoor/Outdoor Cam 1080p" },
+  // Hardwired wall-light camera; mains power asserted in MAINS_CAMERA_MODELS.
+  T84A1: { codec: "camera", name: "Wall Light Cam S100" },
   // Sensors — the concrete sensor kind is curated (DeviceType 2 alone is ambiguous).
   T8900: { codec: "sensor", caps: ["contact"], name: "Entry Sensor" },
   T8910: { codec: "sensor", caps: ["battery"], name: "Motion Sensor" },
@@ -11587,10 +11627,13 @@ var SECURITY_PARAMS = {
     type: "number",
     provenance: "apk"
   },
+  // Cameras and a HomeBase 3 answer a bare number; a HomeBase S1 Pro (T9000) answers a JSON envelope
+  // (`{"ai_switch":1,"smart_detection":…,"devlist":[…]}`).
   1299: {
     name: "hbAiDetectType",
-    type: "number",
-    provenance: "apk"
+    type: "string",
+    provenance: "apk",
+    encoding: "json"
   },
   1309: {
     name: "solarIntensity",
@@ -15139,6 +15182,9 @@ var LIVE_START_RETRANSMIT_MS = 150;
 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;
@@ -15200,13 +15246,18 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   lookupTimer;
   heartbeatTimer;
   connectTimer;
-  /** Our own bound host:port, self-reported inside LOOKUP_WITH_KEY requests (see sendLookups). */
-  selfAddress;
+  /** Extra sockets registered alongside {@link socket} while connecting; see {@link PUNCH_PROBE_SOCKETS}. */
+  probeSockets = [];
+  /** Cloud lookup inputs resolved once for a connection. */
+  cloudLookup;
+  /** Local outbound IPv4 reported inside LOOKUP_WITH_KEY requests. */
+  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. */
@@ -15496,7 +15547,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     }
     const socket = dgram.createSocket("udp4");
     this.socket = socket;
-    socket.on("message", (msg, rinfo) => this.onMessage(msg, rinfo));
+    socket.on("message", (msg, rinfo) => this.onMessage(msg, rinfo, socket));
     socket.on("error", (e) => this.emit("error", e));
     await new Promise((resolve) => {
       socket.bind(() => {
@@ -15507,15 +15558,20 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
         resolve();
       });
     });
-    const boundPort = socket.address().port;
     void _P2PSession.detectLocalIp().then((host) => {
       if (host && !this.closed)
-        this.selfAddress = { host, port: boundPort };
+        this.selfHost = host;
     });
+    const { dskKey, cloudAddresses } = this.cfg;
+    this.cloudLookup = dskKey && cloudAddresses?.length ? { key: dskKey, addresses: cloudAddresses } : void 0;
+    if (this.cloudLookup)
+      await this.startPunchProbes();
+    if (this.closed)
+      return;
     this.trace({
       phase: "lookup-channels",
       local: !this.cfg.noBroadcast || this.cfg.localAddress !== void 0,
-      cloud: this.cfg.dskKey !== void 0 && (this.cfg.cloudAddresses?.length ?? 0) > 0
+      cloud: this.cloudLookup !== void 0
     });
     this.sendLookups();
     this.lookupTimer = setInterval(() => this.sendLookups(), LOOKUP_RETRY_MS);
@@ -15593,14 +15649,20 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       this.send({ host: "255.255.255.255", port: LOCAL_LOOKUP_PORT }, RequestMessageType.LOCAL_LOOKUP, localPayload);
     if (this.cfg.localAddress)
       this.send({ host: this.cfg.localAddress, port: LOCAL_LOOKUP_PORT }, RequestMessageType.LOCAL_LOOKUP, localPayload);
-    if (this.cfg.dskKey && this.cfg.cloudAddresses?.length) {
-      const payload = this.selfAddress ? buildLookupWithKeyPayload(this.cfg.p2pDid, this.selfAddress.host, this.selfAddress.port, this.cfg.dskKey) : buildLookupWithKeyPayload2(this.cfg.p2pDid, this.cfg.dskKey);
-      const type = this.selfAddress ? RequestMessageType.LOOKUP_WITH_KEY : RequestMessageType.LOOKUP_WITH_KEY2;
-      for (const addr of this.cfg.cloudAddresses)
-        this.send(addr, type, payload);
-      this.logger.debug(`[p2p] ${this.cfg.stationSn} sendLookups: cloud -> ${this.cfg.cloudAddresses.map((a) => `${a.host}:${a.port}`).join(", ")} self=${this.selfAddress?.host}:${this.selfAddress?.port}`);
+    const lookup2 = this.cloudLookup;
+    if (lookup2) {
+      for (const socket of [this.socket, ...this.probeSockets])
+        this.sendCloudLookup(socket, lookup2);
+      this.logger.debug(`[p2p] ${this.cfg.stationSn} sendLookups: cloud -> ${lookup2.addresses.map((a) => `${a.host}:${a.port}`).join(", ")} self=${this.selfHost ?? "unknown"}`);
     }
   }
+  /** Register a bound socket's own port with each configured cloud lookup address. */
+  sendCloudLookup(socket, lookup2) {
+    const payload = this.selfHost ? buildLookupWithKeyPayload(this.cfg.p2pDid, this.selfHost, socket.address().port, lookup2.key) : buildLookupWithKeyPayload2(this.cfg.p2pDid, lookup2.key);
+    const type = this.selfHost ? RequestMessageType.LOOKUP_WITH_KEY : RequestMessageType.LOOKUP_WITH_KEY2;
+    for (const addr of lookup2.addresses)
+      this.send(addr, type, payload, socket);
+  }
   /**
    * Route one inbound UDP datagram by its message type, tracing every non-DATA one and any type this session
    * does not model.
@@ -15612,28 +15674,30 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * recur across later probes of it. Correlate an unmodelled type against a WORKING session before reading it
    * as a cause.
    */
-  onMessage(msg, rinfo) {
+  onMessage(msg, rinfo, socket = this.socket) {
+    if (!socket)
+      return;
     if (!hasHeader(msg, ResponseMessageType.DATA)) {
       this.logger.debug(`[p2p] ${this.cfg.stationSn} <<< ${rinfo.address}:${rinfo.port} header=${msg.subarray(0, 2).toString("hex")} len=${msg.length}`);
     }
     if (hasHeader(msg, ResponseMessageType.LOCAL_LOOKUP_RESP)) {
       if (!this.connected)
-        this.beginCheckCam({ host: rinfo.address, port: rinfo.port });
+        this.beginCheckCam({ host: rinfo.address, port: rinfo.port }, socket);
     } else if (hasHeader(msg, ResponseMessageType.LOOKUP_ADDR) || hasHeader(msg, ResponseMessageType.LOOKUP_ADDR2)) {
       if (!this.connected) {
         const addr = parseLookupAddr(msg);
         this.logger.debug(`[p2p] ${this.cfg.stationSn} LOOKUP_ADDR -> ${addr.host}:${addr.port}`);
         if (addr.host !== "0.0.0.0")
-          this.beginCheckCam(addr);
+          this.beginCheckCam(addr, socket);
       }
     } else if (hasHeader(msg, ResponseMessageType.CAM_ID) || hasHeader(msg, ResponseMessageType.TURN_SERVER_CAM_ID)) {
-      this.onConnected({ host: rinfo.address, port: rinfo.port });
+      this.onConnected({ host: rinfo.address, port: rinfo.port }, socket);
     } else if (hasHeader(msg, ResponseMessageType.PONG)) {
       this.lastPongData = msg.length > 4 ? msg.subarray(4) : void 0;
       this.lastPongAt = Date.now();
       this.pathStaleTraced = false;
     } else if (hasHeader(msg, ResponseMessageType.PING)) {
-      this.send({ host: rinfo.address, port: rinfo.port }, RequestMessageType.PONG);
+      this.send({ host: rinfo.address, port: rinfo.port }, RequestMessageType.PONG, void 0, socket);
     } else if (hasHeader(msg, ResponseMessageType.ACK)) {
       this.onAck(msg);
     } else if (hasHeader(msg, ResponseMessageType.DATA)) {
@@ -15643,17 +15707,67 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       this.logger.debug(`[p2p] ${this.cfg.stationSn} UNHANDLED payload hex: ${msg.toString("hex")}`);
     }
   }
-  beginCheckCam(addr) {
+  beginCheckCam(addr, socket) {
     this.logger.debug(`[p2p] ${this.cfg.stationSn} beginCheckCam -> ${addr.host}:${addr.port} (+/-3)`);
     const payload = buildCheckCamPayload(this.cfg.p2pDid);
-    this.send(addr, RequestMessageType.CHECK_CAM, payload);
+    this.send(addr, RequestMessageType.CHECK_CAM, payload, socket);
     for (let p = addr.port - 3; p <= addr.port + 3; p++)
       if (p !== addr.port && p > 0)
-        this.send({ host: addr.host, port: p }, RequestMessageType.CHECK_CAM, payload);
+        this.send({ host: addr.host, port: p }, RequestMessageType.CHECK_CAM, payload, socket);
+  }
+  /** Bind additional UDP source ports before the first cloud lookup. */
+  async startPunchProbes() {
+    await Promise.all(Array.from({ length: PUNCH_PROBE_SOCKETS }, async () => {
+      const probe = dgram.createSocket("udp4");
+      probe.on("error", (error) => this.logger.warn("[p2p] lookup socket error", error.message));
+      probe.on("message", (msg, rinfo) => this.onMessage(msg, rinfo, probe));
+      this.probeSockets.push(probe);
+      await new Promise((resolve) => {
+        let settled = false;
+        const finish = (bound) => {
+          if (settled)
+            return;
+          settled = true;
+          probe.off("error", onError);
+          probe.off("close", onClose);
+          if (!bound) {
+            this.probeSockets = this.probeSockets.filter((socket) => socket !== probe);
+            try {
+              probe.close();
+            } catch {
+            }
+          }
+          resolve();
+        };
+        const onError = () => finish(false);
+        const onClose = () => finish(false);
+        probe.once("error", onError);
+        probe.once("close", onClose);
+        probe.bind(() => finish(true));
+      });
+    }));
+  }
+  /** Close all lookup sockets except the one that completed the handshake. */
+  stopPunchProbes(winner) {
+    for (const probe of this.probeSockets) {
+      if (probe === winner)
+        continue;
+      probe.removeAllListeners("message");
+      probe.close();
+    }
+    this.probeSockets = [];
   }
-  onConnected(addr) {
+  onConnected(addr, socket) {
     if (this.connected)
       return;
+    this.stopPunchProbes(socket);
+    if (this.socket !== socket) {
+      this.socket?.removeAllListeners();
+      this.socket?.close();
+      socket.removeAllListeners("error");
+      socket.on("error", (error) => this.emit("error", error));
+      this.socket = socket;
+    }
     this.connected = true;
     this.connectedAtMs = Date.now();
     this.connecting = false;
@@ -16398,8 +16512,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.
    *
@@ -16409,9 +16522,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);
@@ -16422,18 +16539,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) {
@@ -16464,6 +16661,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;
@@ -16540,11 +16740,11 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     }
     this.emit("data", frame);
   }
-  send(addr, type, payload) {
-    if (!this.socket)
+  send(addr, type, payload, socket = this.socket) {
+    if (!socket)
       return;
     const packet = frameMessage(type, payload);
-    this.socket.send(packet, addr.port, addr.host, (err) => {
+    socket.send(packet, addr.port, addr.host, (err) => {
       if (err)
         this.logger.warn(`[p2p] send err ${addr.host}:${addr.port}`, err.message);
     });
@@ -16553,6 +16753,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     if (this.closed)
       return;
     this.closed = true;
+    this.stopPunchProbes();
     this.connectionGeneration += 1;
     this.level2Key = void 0;
     this.level2Seq = 0;
@@ -23639,24 +23840,35 @@ function readNullTerminated(buf) {
 function nonemptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
-function normalizePushEvent(raw) {
-  const env = raw.payload ?? {};
-  let inner = env.payload ?? env;
-  if (typeof inner === "string") {
-    try {
-      inner = JSON.parse(inner);
-    } catch {
-      inner = void 0;
+function payloadLevels(env) {
+  const levels = [env];
+  for (let level = env; level.payload != null; ) {
+    let next = level.payload;
+    if (typeof next === "string") {
+      try {
+        next = JSON.parse(next);
+      } catch {
+        next = void 0;
+      }
     }
+    level = typeof next === "object" && next ? next : {};
+    levels.push(level);
   }
-  const p = typeof inner === "object" && inner ? inner : {};
+  return levels;
+}
+function normalizePushEvent(raw) {
+  const env = raw.payload ?? {};
+  const levels = payloadLevels(env);
+  const p = levels[levels.length - 1];
+  const deepestFirst = [...levels].reverse();
+  const deviceClaims = deepestFirst.map((l) => l.device_sn).filter(nonemptyString);
+  const levelStations = deepestFirst.map((l) => l.station_sn).filter(nonemptyString);
+  const stationClaims = nonemptyString(p.s) ? [...levelStations, p.s] : levelStations;
   const eventType = p.event_type ?? p.a;
   const url = nonemptyString(p.pic_url) ? p.pic_url : nonemptyString(p.thumbnail) ? p.thumbnail : void 0;
   let thumbnailCandidate;
   if (url) {
-    const deviceClaims = [p.device_sn, env.device_sn].filter(nonemptyString);
     const deviceSn = deviceClaims[0];
-    const stationClaims = [p.station_sn, env.station_sn, p.s].filter(nonemptyString);
     const stationSn = stationClaims[0];
     thumbnailCandidate = {
       url,
@@ -23667,8 +23879,8 @@ function normalizePushEvent(raw) {
     };
   }
   return {
-    deviceSn: p.device_sn ?? env.device_sn ?? p.s,
-    stationSn: p.station_sn ?? env.station_sn,
+    deviceSn: deviceClaims[0] ?? (nonemptyString(p.s) ? p.s : void 0),
+    stationSn: levelStations[0],
     eventType,
     thumbnailUrl: p.pic_url ?? p.thumbnail,
     thumbnailCandidate,
@@ -23808,6 +24020,13 @@ var PushClient = class _PushClient extends EventEmitter8 {
     }
     this.socket?.destroy();
   }
+  /**
+   * Decode one MCS `DataMessageStanza` into a {@link RawPushMessage} and the normalised event.
+   *
+   * `payload` carries the whole app_data envelope, with its `payload` entry (base64 of NUL-terminated
+   * JSON) parsed in place: the envelope's own keys, `device_sn` and `station_sn` among them, sit beside
+   * that entry.
+   */
   handleDataMessage(object) {
     if (object?.persistentId)
       this.persistentIds.push(object.persistentId);
@@ -23832,7 +24051,7 @@ var PushClient = class _PushClient extends EventEmitter8 {
       persistentId: object?.persistentId,
       ttl: object?.ttl,
       sent: object?.sent,
-      payload: data.payload ?? data
+      payload: data
     };
     this.emit("message", raw);
     const event = normalizePushEvent(raw);
@@ -26170,7 +26389,8 @@ var EufyMega = class extends EventEmitter9 {
   }
   /**
    * A station's power tier for the P2P lifecycle: a HomeBase/station is `"wired"` (persistent); a
-   * standalone device is `"battery"` iff its resolved capabilities include `battery`, else `"wired"`.
+   * standalone device is `"battery"` iff its resolved capabilities include `battery` and it is not a
+   * confirmed mains-only camera model, else `"wired"`.
    * Keyed on the STATION's own power, never a child's (a battery cam attached to a wired HomeBase draws
    * from the base's persistent session). Reads capabilities on the client side — no model type leaks to
    * transport (the router only ever sees the `"wired"|"battery"` string).
@@ -26188,7 +26408,7 @@ var EufyMega = class extends EventEmitter9 {
       category: d.category,
       params: d.params ?? {}
     }).capabilities;
-    return caps.includes("battery") ? "battery" : "wired";
+    return cameraPowerTier(d.model, new Set(caps));
   }
   /**
    * Speculatively open the P2P session of the station behind `deviceSn`, if the caller opted this