@mega-yfue/eufy-sdk 0.5.0-beta.26 → 0.5.0-beta.27

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // dist/client/eufy-mega.js
-import { EventEmitter as EventEmitter12 } from "node:events";
+import { EventEmitter as EventEmitter13 } from "node:events";
 
 // dist/transport/http/mega-client.js
 import { createHash as createHash3 } from "node:crypto";
@@ -14514,6 +14514,19 @@ function decodeMapFrame(frame, codec) {
   return READERS.get(frame.channelId)?.(frame.payload, codec);
 }
 
+// dist/transport/abortable.js
+function abortable(work, signal) {
+  if (!signal)
+    return work;
+  signal.throwIfAborted();
+  return Promise.race([
+    work,
+    new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+    })
+  ]);
+}
+
 // dist/transport/p2p/command-router.js
 import { setTimeout as sleep2 } from "node:timers/promises";
 
@@ -17860,6 +17873,18 @@ function startCodeBegin(buf, payloadOffset) {
     return threeByte - 1;
   return threeByte;
 }
+function hasIdr(buf, codec) {
+  for (const p of nalStarts(buf)) {
+    const b = buf[p];
+    if (codec === "h265") {
+      const t = b >> 1 & 63;
+      if (t === 19 || t === 20)
+        return true;
+    } else if ((b & 31) === 5)
+      return true;
+  }
+  return false;
+}
 var MAX_CODED_DIMENSION = 32768;
 var H264_CHROMA_PROFILES = /* @__PURE__ */ new Set([100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134, 135, 144]);
 var CHROMA_SUBSAMPLING = {
@@ -19630,6 +19655,14 @@ var SharedLiveSource = class {
       this.opts.onIdle?.();
   }
 };
+function attachUnlessAborted(source, signal) {
+  const consumer = source.attach();
+  if (signal?.aborted) {
+    consumer.detach();
+    signal.throwIfAborted();
+  }
+  return consumer;
+}
 
 // dist/transport/p2p/session-manager.js
 var SessionSupersededError = class extends Error {
@@ -20986,17 +21019,6 @@ function stationChannels(devices) {
 
 // dist/transport/p2p/command-router.js
 var DIRECT_CMD_SENDS = 5;
-function abortable(work, signal) {
-  if (!signal)
-    return work;
-  signal.throwIfAborted();
-  return Promise.race([
-    work,
-    new Promise((_resolve, reject) => {
-      signal.addEventListener("abort", () => reject(signal.reason), { once: true });
-    })
-  ]);
-}
 var LEVEL2_GRACE_MS = 25e3;
 var LEVEL2_SETTLE_MS = 8e3;
 var P2P_STATION_WAITS = {
@@ -21488,11 +21510,11 @@ var P2PCommandRouter = class _P2PCommandRouter {
       },
       live: async (opts) => {
         const source = await this.sharedLiveSourceFor(sn, opts, true);
-        return this.attachUnlessAborted(source, opts?.signal);
+        return attachUnlessAborted(source, opts?.signal);
       },
       openReadable: async (opts) => {
         const source = await this.sharedLiveSourceFor(sn, opts ?? {}, true);
-        return openReadableFromConsumer(this.attachUnlessAborted(source, opts?.signal), opts);
+        return openReadableFromConsumer(attachUnlessAborted(source, opts?.signal), opts);
       },
       recordFragments: (opts) => this.recordFragments(sn, opts),
       talkback: (opts) => this.openTalkback(sn, opts),
@@ -21860,22 +21882,6 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * A still with no live sibling re-asserts, so a tile refreshing on a quiet station is
    * unaffected.
    */
-  /**
-   * Attach a consumer, unless the caller has already abandoned the call.
-   *
-   * The acquisition it just waited through can outlast the caller's interest, and a consumer attached for
-   * somebody who has gone keeps the pull warm for nobody. Detaching immediately gives the pull back, which
-   * lets it linger and fall away if this was the only thing holding it, and leaves it untouched if it was
-   * not.
-   */
-  attachUnlessAborted(source, signal) {
-    const consumer = source.attach();
-    if (signal?.aborted) {
-      consumer.detach();
-      signal.throwIfAborted();
-    }
-    return consumer;
-  }
   /**
    * Dispose one cached live source and forget it, so the next acquisition builds a fresh one. Its claim
    * on a session goes with it, and a media session opened for this source alone is closed: nothing else
@@ -22645,20 +22651,21 @@ var P2PCommandRouter = class _P2PCommandRouter {
   }
 };
 
-// dist/transport/rtc/session.js
-import { EventEmitter as EventEmitter9 } from "node:events";
-
-// dist/transport/rtc/peer.js
+// dist/transport/rtc/live.js
 import { EventEmitter as EventEmitter7 } from "node:events";
 
 // dist/transport/rtc/portal-packet.js
 var MAGIC2 = Buffer.from("XZYH", "ascii");
 var PORTAL_HEADER_LENGTH = 16;
+var PORTAL_CMD_SET_PAYLOAD = 1350;
+var PORTAL_STATION_CHANNEL = 255;
 var PortalLinkType = {
   /** Command channel: requests out, acknowledgements back. */
   COMMAND: 1,
   /** Station-originated frames: pushes, notify payloads, control results. */
-  NOTIFY: 3
+  NOTIFY: 3,
+  /** Live video. */
+  LIVE: 5
 };
 function encodeLe(value, width) {
   const buf = Buffer.alloc(width);
@@ -22750,6 +22757,159 @@ var SegmentCounter = class {
   }
 };
 
+// dist/transport/rtc/live.js
+var LIVE_START = 1003;
+var LIVE_STOP = 1004;
+var LIVE_MEDIA = 1300;
+var LIVE_MEDIA_CHANNEL = 101;
+var LIVE_STREAM_ID = 1;
+var KEEPALIVE_MS = 29e3;
+var KEEPALIVE = Buffer.from("0009000010000000000000006300000000000000585a5948730400000000000000000002", "hex");
+var MEDIA_HEADER_LENGTH = 22;
+var STREAM_TYPE_HEVC = 1;
+function parseMediaBody(body) {
+  if (body.length < MEDIA_HEADER_LENGTH || body[5] !== STREAM_TYPE_HEVC)
+    return void 0;
+  const length = body.readUInt32LE(0);
+  if (body.length < MEDIA_HEADER_LENGTH + length)
+    return void 0;
+  return {
+    data: body.subarray(MEDIA_HEADER_LENGTH, MEDIA_HEADER_LENGTH + length),
+    width: body.readUInt16LE(10),
+    height: body.readUInt16LE(12)
+  };
+}
+var RtcLiveStream = class extends EventEmitter7 {
+  opts;
+  running = false;
+  startSegment = -1;
+  keepalive;
+  width = 0;
+  height = 0;
+  onMedia = (frame) => this.onMediaFrame(frame);
+  onCommand = (frame, linkType) => this.onCommandFrame(frame, linkType);
+  onClose = () => this.fail(new Error(`rtc live ${this.tag}: session closed`));
+  constructor(opts) {
+    super();
+    this.opts = opts;
+  }
+  get tag() {
+    return `${this.opts.stationSn}#${this.opts.channel}`;
+  }
+  start() {
+    if (this.running)
+      return this;
+    const { session, seg, accountId } = this.opts;
+    this.running = true;
+    session.on("mediaData", this.onMedia);
+    session.on("commandData", this.onCommand);
+    session.on("close", this.onClose);
+    this.startSegment = seg.next();
+    const sent = session.sendCommand(buildPortalPacket({
+      commandId: PORTAL_CMD_SET_PAYLOAD,
+      channel: PORTAL_STATION_CHANNEL,
+      segment: this.startSegment,
+      isResponse: LIVE_STREAM_ID,
+      payload: {
+        account_id: accountId,
+        cmd: LIVE_START,
+        payload: {
+          ClientOS: "WEB",
+          entrytype: 0,
+          camera_type: 0,
+          key: "",
+          msg_id: 116,
+          audio_chn: -1,
+          streamtype: 2,
+          stitch_mode: 1,
+          chn_list: [{ index: 0, chn: this.opts.channel, sensor: 0, isUps: 0, isClicked: true }],
+          pip_cord: { x1: 0, y1: 0, x2: 0, y2: 0 },
+          station_video_type: 6,
+          play_id: 1
+        }
+      }
+    }));
+    if (!sent) {
+      queueMicrotask(() => this.fail(new Error(`rtc live ${this.tag}: command channel not open`)));
+      return this;
+    }
+    this.keepalive = setInterval(() => {
+      if (!session.sendRaw(KEEPALIVE))
+        this.opts.logger?.warn?.(`[rtc] ${this.tag} keepalive not sent`);
+    }, KEEPALIVE_MS);
+    this.keepalive.unref?.();
+    this.opts.logger?.debug?.(`[rtc] ${this.tag} live start sent`);
+    return this;
+  }
+  stop() {
+    if (!this.running)
+      return;
+    this.teardown();
+    const { session, seg, accountId } = this.opts;
+    session.sendCommand(buildPortalPacket({
+      commandId: PORTAL_CMD_SET_PAYLOAD,
+      channel: PORTAL_STATION_CHANNEL,
+      segment: seg.next(),
+      isResponse: LIVE_STREAM_ID,
+      payload: { account_id: accountId, cmd: LIVE_STOP, payload: {} }
+    }));
+    this.emit("stop");
+  }
+  teardown() {
+    this.running = false;
+    if (this.keepalive)
+      clearInterval(this.keepalive);
+    this.keepalive = void 0;
+    const { session } = this.opts;
+    session.off("mediaData", this.onMedia);
+    session.off("commandData", this.onCommand);
+    session.off("close", this.onClose);
+  }
+  fail(err) {
+    if (!this.running)
+      return;
+    this.teardown();
+    this.emit("error", err);
+  }
+  /** The start's ACK: a non-zero result code ends the pull. */
+  onCommandFrame(frame, linkType) {
+    const p = parsePortalPacket(frame, linkType);
+    if (!p?.isResponse || p.segment !== this.startSegment || p.commandId !== PORTAL_CMD_SET_PAYLOAD)
+      return;
+    if (p.errCode !== 0)
+      this.fail(new Error(`rtc live ${this.tag}: start refused (err ${p.errCode})`));
+  }
+  onMediaFrame(frame) {
+    const h = parsePortalHeader(frame);
+    if (!h || h.commandId !== LIVE_MEDIA || h.channel !== LIVE_MEDIA_CHANNEL)
+      return;
+    if (h.paramLength > frame.length - PORTAL_HEADER_LENGTH)
+      return;
+    const media = parseMediaBody(frame.subarray(PORTAL_HEADER_LENGTH, PORTAL_HEADER_LENGTH + h.paramLength));
+    if (!media)
+      return;
+    const { data, width, height } = media;
+    if (width && height) {
+      this.width = width;
+      this.height = height;
+    }
+    const out = {
+      codec: "h265",
+      data,
+      keyframe: hasIdr(data, "h265"),
+      width: this.width,
+      height: this.height
+    };
+    this.emit("video", out);
+  }
+};
+
+// dist/transport/rtc/session.js
+import { EventEmitter as EventEmitter10 } from "node:events";
+
+// dist/transport/rtc/peer.js
+import { EventEmitter as EventEmitter8 } from "node:events";
+
 // dist/transport/rtc/ptcs-framer.js
 var MAGIC3 = Buffer.from("PTCS", "ascii");
 var PTCS_HEADER_LENGTH = 28;
@@ -22759,10 +22919,15 @@ var FLAG_LAST = 1024;
 var LENGTH_MASK = 1023;
 var PtcsChannel = {
   COMMAND: 0,
-  NOTIFY: 2
+  NOTIFY: 2,
+  LIVE: 5
 };
 function linkTypeForChannel(channel) {
-  return channel === PtcsChannel.NOTIFY ? PortalLinkType.NOTIFY : PortalLinkType.COMMAND;
+  if (channel === PtcsChannel.NOTIFY)
+    return PortalLinkType.NOTIFY;
+  if (channel === PtcsChannel.LIVE)
+    return PortalLinkType.LIVE;
+  return PortalLinkType.COMMAND;
 }
 var PTCS_STALE_MS = 15e3;
 function parsePtcsHeader(packet) {
@@ -23028,7 +23193,7 @@ async function loadNativePeerFactory() {
   return (name, config) => new ndc.PeerConnection(name, config);
 }
 var ANSWER_TIMEOUT_MS = 15e3;
-var RtcPeer = class extends EventEmitter7 {
+var RtcPeer = class extends EventEmitter8 {
   opts;
   pc;
   channels = /* @__PURE__ */ new Map();
@@ -23145,6 +23310,16 @@ var RtcPeer = class extends EventEmitter7 {
     }
     this.addNow(candidate);
   }
+  /**
+   * Send bytes on the command channel as they are, without PTCS framing; false when it isn't open. The
+   * portal's data-channel keepalive rides the wire unframed.
+   */
+  sendRaw(bytes2) {
+    const dc = this.channels.get(COMMAND_CHANNEL);
+    if (!dc?.isOpen())
+      return false;
+    return dc.sendMessageBinary(bytes2);
+  }
   /**
    * Send one portal packet on the command channel, through the framer. False when the channel is not
    * usable or the native send refused a wire packet, so a dropped frame does not read as success.
@@ -23251,7 +23426,7 @@ var RtcPeer = class extends EventEmitter7 {
 };
 
 // dist/transport/rtc/signaling.js
-import { EventEmitter as EventEmitter8 } from "node:events";
+import { EventEmitter as EventEmitter9 } from "node:events";
 import { createHmac as createHmac3, randomUUID as randomUUID2 } from "node:crypto";
 var RTC_WS_PATH = "/v1/rtc/ws/join?reqtype=nvr";
 var RTC_SIGN_PATH = "/v1/smart/nvr/ws/sign";
@@ -23267,7 +23442,7 @@ var defaultSocket = (url, init) => new WebSocket(url, {
   protocols: init.protocols,
   headers: { Origin: init.origin }
 });
-var RtcSignalingClient = class extends EventEmitter8 {
+var RtcSignalingClient = class extends EventEmitter9 {
   opts;
   ws;
   sign;
@@ -23492,7 +23667,7 @@ var RtcSignalingClient = class extends EventEmitter8 {
 
 // dist/transport/rtc/session.js
 var AUTH_TIMEOUT_MS = 15e3;
-var RtcSession = class extends EventEmitter9 {
+var RtcSession = class extends EventEmitter10 {
   opts;
   signaling;
   peer;
@@ -23544,7 +23719,12 @@ var RtcSession = class extends EventEmitter9 {
       }
     });
     this.peer.on("error", (e) => this.emit("error", e));
-    this.peer.on("data", (frame, linkType) => this.emit("commandData", frame, linkType));
+    this.peer.on("data", (frame, linkType) => {
+      if (linkType === PortalLinkType.LIVE)
+        this.emit("mediaData", frame);
+      else
+        this.emit("commandData", frame, linkType);
+    });
   }
   get isConnected() {
     return this.connected;
@@ -23569,6 +23749,10 @@ var RtcSession = class extends EventEmitter9 {
   sendCommand(portalPacket) {
     return this.peer.sendCommand(portalPacket);
   }
+  /** Send unframed bytes on the command channel; false when it isn't open. */
+  sendRaw(bytes2) {
+    return this.peer.sendRaw(bytes2);
+  }
   /**
    * Hang up and tear both sides down; `close` fires once, here if nothing announced it before. A
    * `connect()` still waiting for the signalling auth is rejected and its timer stopped.
@@ -23715,16 +23899,21 @@ var RtcSession = class extends EventEmitter9 {
 };
 
 // dist/transport/rtc/command-router.js
-var PORTAL_CMD_SET_PAYLOAD = 1350;
 var PORTAL_CMD_CONTROL_PAYLOAD = 1700;
 var PORTAL_CMD_NOTIFY_PAYLOAD = 1351;
-var PORTAL_STATION_CHANNEL = 255;
 var ACK_TIMEOUT_MS = 8e3;
 var CONNECT_TIMEOUT_MS2 = 12e3;
 var IDLE_CLOSE_MS = 6e4;
+var StationStreamBusyError = class extends Error {
+  constructor(stationSn, servingSn) {
+    super(`rtc live: ${stationSn} is serving ${servingSn}; the station streams one camera at a time`);
+    this.name = "StationStreamBusyError";
+  }
+};
 var RtcCommandRouter = class {
   deps;
   sessions = /* @__PURE__ */ new Map();
+  lives = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
@@ -23748,11 +23937,112 @@ var RtcCommandRouter = class {
     st.queue = run.catch(() => void 0);
     return run;
   }
-  /** Tear down every station session (logout / shutdown). */
+  /**
+   * The media of a camera on a T9000: live video, a readable feed and a live still over the station's
+   * session. Recording has no wire here and is refused; the optional members it has no wire for are absent.
+   */
+  mediaProviderFor(route) {
+    return {
+      live: (opts) => this.withLiveSource(route, opts ?? {}, (source) => attachUnlessAborted(source, opts?.signal)),
+      openReadable: (opts) => this.withLiveSource(route, opts ?? {}, (source) => openReadableFromConsumer(attachUnlessAborted(source, opts?.signal), opts)),
+      snapshotLive: (opts) => this.withLiveSource(route, opts ?? {}, (source) => captureSnapshotFromShared(source, { ...opts, logger: this.deps.logger, ffmpegPath: this.deps.ffmpegPath })).catch((e) => {
+        if (!(e instanceof StationStreamBusyError))
+          throw e;
+        throw new LiveSnapshotUnavailableError("source-failed", e.message, { cause: e });
+      }),
+      record: async () => {
+        throw new Error(`record is not available for ${route.cameraSn} over the T9000 control channel`);
+      }
+    };
+  }
+  /**
+   * Tear down every station session (logout / shutdown). Each live source is disposed before its session
+   * closes, so its consumers end cleanly and its stop still rides the session.
+   */
   close() {
+    for (const [sn, live] of this.lives) {
+      this.lives.delete(sn);
+      live.source.dispose();
+    }
     for (const [sn, st] of this.sessions)
       this.drop(sn, st);
   }
+  /**
+   * Hand `use` the station's live source for this camera, in the same turn the source is created or reused,
+   * so a consumer it attaches is counted before any other caller looks.
+   *
+   * The station streams one camera at a time. Another camera whose source has consumers refuses this one,
+   * before the session is awaited and again after; one with none (never attached or lingering)
+   * holds nothing a viewer needs, so it is disposed and the slot taken. The first caller's
+   * {@link SharedSourceHints} configure a new source.
+   */
+  async withLiveSource(route, opts, use) {
+    opts.signal?.throwIfAborted();
+    this.refuseIfWatched(route);
+    const identity = this.deps.identity();
+    if (!identity)
+      throw new Error(`rtc: not logged in, cannot open ${route.stationSn}`);
+    const accountId = route.adminUserId || identity.userId;
+    const st = await abortable(this.stationSession(route, accountId, identity), opts.signal);
+    this.refuseIfWatched(route);
+    const current = this.lives.get(route.stationSn);
+    if (current && current.cameraSn !== route.cameraSn) {
+      this.deps.logger?.debug?.(`[rtc] ${route.stationSn} releasing the unwatched source of ${current.cameraSn} for ${route.cameraSn}`);
+      this.lives.delete(route.stationSn);
+      current.source.dispose();
+    }
+    let live = this.lives.get(route.stationSn);
+    if (!live) {
+      live = { cameraSn: route.cameraSn, source: this.newLiveSource(route, st, accountId, opts) };
+      this.lives.set(route.stationSn, live);
+    }
+    return await use(live.source);
+  }
+  /** Refuse a camera while another camera on its station has consumers. */
+  refuseIfWatched(route) {
+    const current = this.lives.get(route.stationSn);
+    if (current && current.cameraSn !== route.cameraSn && current.source.consumerCount > 0) {
+      throw new StationStreamBusyError(route.stationSn, current.cameraSn);
+    }
+  }
+  newLiveSource(route, st, accountId, hints) {
+    let leased = false;
+    const release = () => {
+      if (!leased)
+        return;
+      leased = false;
+      st.leases = Math.max(0, st.leases - 1);
+      this.touch(route.stationSn, st);
+    };
+    const source = new SharedLiveSource({
+      makeStream: () => new RtcLiveStream({
+        session: st.session,
+        seg: st.seg,
+        stationSn: route.stationSn,
+        channel: route.channel,
+        accountId,
+        logger: this.deps.logger
+      }),
+      label: `${route.stationSn}#${route.channel}`,
+      logger: this.deps.logger,
+      powered: hints.powered,
+      preBufferSeconds: hints.preBufferSeconds,
+      onActive: () => {
+        if (leased)
+          return;
+        leased = true;
+        st.leases++;
+        if (st.idle)
+          clearTimeout(st.idle);
+      },
+      onStopped: () => {
+        release();
+        if (this.lives.get(route.stationSn)?.source === source)
+          this.lives.delete(route.stationSn);
+      }
+    });
+    return source;
+  }
   /**
    * Completes on the command ACK or a correlated control-result notification. The notification must
    * match the request channel, parameter and segment and contain a structured payload. Receipt does
@@ -23822,7 +24112,7 @@ var RtcCommandRouter = class {
       peer: { logger: this.deps.logger, iceTransportPolicy: route.iceTransportPolicy }
     });
     const ready = this.bringUp(sn, session);
-    const st = { session, seg: new SegmentCounter(), ready, queue: Promise.resolve() };
+    const st = { session, seg: new SegmentCounter(), ready, queue: Promise.resolve(), leases: 0 };
     session.on("error", (e) => this.deps.onError?.(e));
     session.on("close", () => {
       if (this.sessions.get(sn) === st)
@@ -23876,6 +24166,8 @@ var RtcCommandRouter = class {
   touch(sn, st) {
     if (st.idle)
       clearTimeout(st.idle);
+    if (st.leases > 0)
+      return;
     st.idle = setTimeout(() => this.drop(sn, st), IDLE_CLOSE_MS);
     st.idle.unref?.();
   }
@@ -25505,7 +25797,7 @@ async function resolveLightEffect(mega, lightId) {
 }
 
 // dist/transport/push/push-client.js
-import { EventEmitter as EventEmitter11 } from "node:events";
+import { EventEmitter as EventEmitter12 } from "node:events";
 import tls2 from "node:tls";
 
 // dist/transport/push/proto.js
@@ -25760,7 +26052,7 @@ var MessageTag;
 })(MessageTag || (MessageTag = {}));
 
 // dist/transport/push/parser.js
-import { EventEmitter as EventEmitter10 } from "node:events";
+import { EventEmitter as EventEmitter11 } from "node:events";
 var State;
 (function(State2) {
   State2[State2["VERSION_TAG_AND_SIZE"] = 0] = "VERSION_TAG_AND_SIZE";
@@ -25778,7 +26070,7 @@ var TAG_TO_TYPE = {
   [MessageTag.DataMessageStanza]: "mcs_proto.DataMessageStanza",
   [MessageTag.StreamErrorStanza]: "mcs_proto.StreamErrorStanza"
 };
-var McsParser = class extends EventEmitter10 {
+var McsParser = class extends EventEmitter11 {
   data = Buffer.alloc(0);
   state = State.VERSION_TAG_AND_SIZE;
   messageTag = 0;
@@ -25956,7 +26248,7 @@ function normalizePushEvent(raw) {
     raw
   };
 }
-var PushClient = class _PushClient extends EventEmitter11 {
+var PushClient = class _PushClient extends EventEmitter12 {
   creds;
   logger;
   /** Consecutive MCS login rejections tolerated (self-healing propagation) before surfacing an error. */
@@ -27143,6 +27435,8 @@ function tuyaDevIdFrom(raw) {
 var DEFAULT_POLL_MS = 6e5;
 var DEFAULT_PREWARM_TIERS = ["wired", "battery"];
 var SESSION_RECYCLE_WAIT_MS = 5e3;
+var PUSH_RETRY_MIN_MS = 3e4;
+var PUSH_RETRY_MAX_MS = 6e5;
 var RealtimeStartupSupersededError = class extends Error {
 };
 var RefreshWindowClosedError = class extends Error {
@@ -27158,7 +27452,7 @@ function readinessSnapshot(readiness, state = readiness.state) {
     wiredP2p: Object.freeze({ ...readiness.wiredP2p })
   });
 }
-var EufyMega = class extends EventEmitter12 {
+var EufyMega = class extends EventEmitter13 {
   opts;
   mega;
   /**
@@ -27241,6 +27535,8 @@ var EufyMega = class extends EventEmitter12 {
   mapStores = /* @__PURE__ */ new Map();
   /** Re-armed after each cloud-param poll; cancelled by {@link disconnect}. */
   pollTimer = new Timer();
+  /** Armed while a failed push bring-up waits to be retried; cancelled by {@link disconnect}. */
+  pushRetryTimer = new Timer();
   constructor(opts) {
     super();
     this.opts = opts;
@@ -27285,6 +27581,7 @@ var EufyMega = class extends EventEmitter12 {
       shard: () => this.mega.rtcShard,
       country: opts.countryCode,
       logger: opts.logger,
+      ffmpegPath: opts.ffmpegPath,
       onError: (e) => this.reportError(e)
     });
     this.mqtt = new MqttCommandRouter({
@@ -27996,7 +28293,7 @@ var EufyMega = class extends EventEmitter12 {
    * current. With nothing retained the refusal stands.
    */
   mediaProviderFor(sn) {
-    const media = this.p2p.mediaProviderFor(sn);
+    const media = this.rtcMediaFor(sn) ?? this.p2p.mediaProviderFor(sn);
     const cache = this.storedImages;
     if (!cache)
       return media;
@@ -28056,24 +28353,48 @@ var EufyMega = class extends EventEmitter12 {
         return this.tuya.dispatchCommand(sn, cmd);
       return this.mqtt.dispatchCommand(sn, cmd);
     }
+    const route = this.rtcRouteFor(sn);
+    if (route) {
+      if (route.attached && this.registry.serialForFrame(route.stationSn, cmd.channel) !== sn)
+        return Promise.reject(new Error("RTC command requires an unambiguous attached-device channel"));
+      return this.rtc.dispatchCommand(route, cmd);
+    }
+    return this.p2p.dispatchCommand(sn, cmd);
+  }
+  /**
+   * The RTC route for a T9000 or T8N00 station or a device attached to one, decided by the station's model
+   * classification; `undefined` for any other device. A T8N00 route carries its native `call` signalling. The admin id is the station's
+   * `member.admin_user_id`, else the logged-in user.
+   */
+  rtcRouteFor(sn) {
     const devices = this.registry.list();
     const target = devices.find((d) => d.sn === sn);
     const stationSn = target?.stationSn || sn;
     const station = devices.find((d) => d.sn === stationSn);
-    const stationRaw = station?.raw ?? {};
-    const deviceType = typeof stationRaw.device_type === "number" ? stationRaw.device_type : void 0;
+    const raw = station?.raw ?? {};
+    const deviceType = typeof raw.device_type === "number" ? raw.device_type : void 0;
     const family = { deviceType, model: station?.model };
     const native = isNvrT8N00(family);
-    if (target && station && (isStation9000(family) || native)) {
-      const attached = stationSn !== sn;
-      if (attached && this.registry.serialForFrame(stationSn, cmd.channel) !== sn)
-        return Promise.reject(new Error("RTC command requires an unambiguous attached-device channel"));
-      const member = stationRaw.member?.admin_user_id;
-      const adminUserId = typeof member === "string" && member ? member : void 0;
-      const base = { stationSn, adminUserId, attached };
-      return this.rtc.dispatchCommand(native ? { ...base, signalingMode: "call", iceTransportPolicy: "all" } : base, cmd);
-    }
-    return this.p2p.dispatchCommand(sn, cmd);
+    if (!target || !station || !(isStation9000(family) || native))
+      return void 0;
+    const member = raw.member?.admin_user_id;
+    const adminUserId = typeof member === "string" && member ? member : void 0;
+    const base = { stationSn, adminUserId, attached: stationSn !== sn };
+    return native ? { ...base, signalingMode: "call", iceTransportPolicy: "all" } : base;
+  }
+  /**
+   * The RTC media provider for a camera attached to a T9000 whose `device_channel` resolves back to it on
+   * the station; `undefined` otherwise, including a camera behind a T8N00, whose route carries commands only.
+   */
+  rtcMediaFor(sn) {
+    const route = this.rtcRouteFor(sn);
+    if (!route?.attached || route.signalingMode === "call")
+      return void 0;
+    const raw = this.registry.list().find((d) => d.sn === sn)?.raw ?? {};
+    const channel = typeof raw.device_channel === "number" ? raw.device_channel : void 0;
+    if (channel === void 0 || this.registry.serialForFrame(route.stationSn, channel) !== sn)
+      return void 0;
+    return this.rtc.mediaProviderFor({ ...route, cameraSn: sn, channel });
   }
   /**
    * List + classify devices across all houses (mega API). Each device is tagged with its API backend
@@ -28307,13 +28628,38 @@ var EufyMega = class extends EventEmitter12 {
       this.schedulePoll();
       const failures = readiness.push.failed + readiness.mqtt.failed + readiness.wiredP2p.failed;
       this.settleRealtimeGeneration(generation, failures || startupFailed ? "partial" : "ready");
+      if (readiness.push.failed)
+        this.retryPush(generation);
     } catch (e) {
       this.reportError(e);
       readiness.push.failed += readiness.push.pending;
       readiness.push.pending = 0;
       this.settleRealtimeGeneration(generation, epoch === this.realtimeEpoch ? "partial" : "superseded");
+      if (epoch === this.realtimeEpoch)
+        this.retryPush(generation);
     }
   }
+  /**
+   * Bring push up again after the generation's startup attempt failed, backing off between attempts
+   * until one connects, the generation is superseded, or it is aborted by {@link disconnect}.
+   *
+   * The MCS socket reconnects on its own only once it has connected. The settled
+   * {@link RealtimeReadiness} is a startup snapshot and is not revised when a retry connects.
+   */
+  retryPush(generation, delayMs = PUSH_RETRY_MIN_MS) {
+    this.pushRetryTimer.arm(delayMs, () => {
+      this.startPush(generation.abort.signal).then((client) => {
+        if (generation.epoch !== this.realtimeEpoch)
+          return client.close();
+        this.pushClient = client;
+      }, (error) => {
+        if (generation.epoch !== this.realtimeEpoch)
+          return;
+        this.reportError(error);
+        this.retryPush(generation, Math.min(delayMs * 2, PUSH_RETRY_MAX_MS));
+      });
+    });
+  }
   /** Resolve a generation with an immutable count snapshot; later transport completions are ignored. */
   settleRealtimeGeneration(generation, state) {
     if (generation.settled)
@@ -29169,6 +29515,7 @@ var EufyMega = class extends EventEmitter12 {
    */
   async teardownRealtime() {
     this.pollTimer.cancel();
+    this.pushRetryTimer.cancel();
     this.lastStateAnnounced.clear();
     await this.closeMqttTransports();
     this.rtc.close();
@@ -29676,7 +30023,7 @@ var SolixClient = class _SolixClient {
 };
 
 // dist/transport/mqtt/solix-mqtt.js
-import { EventEmitter as EventEmitter13 } from "node:events";
+import { EventEmitter as EventEmitter14 } from "node:events";
 var SOLIX_METER_FIELD_NAMES = {
   168: "meterPowerL1",
   // Anker Modbus: primary_phase_1_active_power
@@ -29854,7 +30201,7 @@ function addSolarbankScalars(frame, out) {
     out.gridExportLimit = df.readUInt16LE(5);
   }
 }
-var SolixMqtt = class extends EventEmitter13 {
+var SolixMqtt = class extends EventEmitter14 {
   transport;
   appName;
   userId;