@mega-yfue/eufy-sdk 0.5.0-beta.1 → 0.5.0-beta.11

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // dist/client/eufy-mega.js
-import { EventEmitter as EventEmitter9 } from "node:events";
+import { EventEmitter as EventEmitter12 } from "node:events";
 
 // dist/transport/http/mega-client.js
 import { createHash as createHash3 } from "node:crypto";
@@ -1563,6 +1563,8 @@ function withoutTokenEcho(text2) {
 var MegaHttpClient = class {
   cfg;
   region;
+  /** The host `estimate_domain` answered, persisted with the session. */
+  estimatedDomain = "";
   bootstrapDomain;
   sessionKey;
   /** Per-host ECDH session keys for non-mega gateways (e.g. eufylife) keyed by host. */
@@ -1643,6 +1645,7 @@ var MegaHttpClient = class {
     if (!isSessionValid(saved) || !saved)
       return void 0;
     this.region = saved.region;
+    this.estimatedDomain = saved.estimatedDomain ?? "";
     this.auth_ = {
       userId: saved.userId,
       accountUserId: saved.accountUserId,
@@ -1667,6 +1670,24 @@ var MegaHttpClient = class {
   get regionShard() {
     return this.region;
   }
+  /**
+   * The shard the RTC signalling signs on: the regional prefix of the estimated domain
+   * (`…-ie-…`/`…-ie.` → `ie-pr`), else {@link regionShard}. The eu/us classification cannot name shards
+   * like `ie-pr`, whose accounts need the IE sign host and cluster.
+   */
+  get rtcShard() {
+    const m = /-([a-z]{2})(?:[.-]|$)/i.exec(this.estimatedDomain);
+    return m ? `${m[1].toLowerCase()}-pr` : this.region;
+  }
+  /**
+   * The credentials the RTC signalling needs; `undefined` while logged out. The sign is refused
+   * ("gtoken not equal userid") unless its gtoken is the one every authed HTTP call carries.
+   */
+  rtcIdentity() {
+    if (!this.auth_)
+      return void 0;
+    return { authToken: this.auth_.authToken, userId: this.auth_.userId, gtoken: gtoken(this.gtokenUserId()) };
+  }
   /**
    * The name commands attribute themselves to — {@link MegaClientConfig.accountName} when the config
    * pins one (trimmed; blank counts as unset), otherwise the logged-in account's display name, which
@@ -1764,6 +1785,7 @@ var MegaHttpClient = class {
     const env = res.data;
     const d = env?.data ?? {};
     const domain = d.domain ?? d.host ?? d.server_secret_info ?? "";
+    this.estimatedDomain = domain;
     const blob = JSON.stringify(d);
     if (blob.includes("-eu-") || domain.includes("-eu-"))
       this.region = "eu-pr";
@@ -2422,6 +2444,7 @@ ${this.auth_?.authToken ?? ""}`;
       authToken: this.auth_.authToken,
       geoKey: this.auth_.geoKey,
       region: this.region,
+      estimatedDomain: this.estimatedDomain,
       openudid: this.openudid,
       phoneModel: this.phoneModel,
       mediaUserAgent: this.mediaUserAgent,
@@ -5060,6 +5083,7 @@ var isIndoorCamera = (ctx) => has(INDOOR_CAMERA_TYPES, ctx.deviceType);
 var isIndoorCamMini = (ctx) => ctx.deviceType === DeviceType.INDOOR_COST_DOWN_CAMERA;
 var isIndoorPanTiltS350 = (ctx) => has(INDOOR_PT_S350_TYPES, ctx.deviceType);
 var isHomeBase = (ctx) => has(HOMEBASE_TYPES, ctx.deviceType);
+var isStation9000 = (ctx) => ctx.deviceType === DeviceType.STATION_9000;
 var isAiotVacuum = (ctx) => ctx.category !== "eufy_home_tuya";
 var isTuyaVacuum = (ctx) => ctx.category === "eufy_home_tuya";
 
@@ -11179,8 +11203,10 @@ function resolveDevice(rec) {
 }
 function resolveProperties(rec, codec, capabilities) {
   const paramIds = /* @__PURE__ */ new Set();
-  if (rec.params && typeof rec.params === "object") {
-    for (const k of Object.keys(rec.params)) {
+  for (const reported of [rec.params, rec.dpParams]) {
+    if (!reported || typeof reported !== "object")
+      continue;
+    for (const k of Object.keys(reported)) {
       const n = Number(k);
       if (Number.isFinite(n))
         paramIds.add(n);
@@ -15699,8 +15725,8 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     return this.connected;
   }
   /**
-   * Ask the OS for {@link RECEIVE_BUFFER_BYTES} on a bound socket, and warn once per session when it grants
-   * less or refuses.
+   * Ask the OS for {@link RECEIVE_BUFFER_BYTES} on a bound socket, and log once per session when it grants
+   * less (debug) or refuses (warn).
    *
    * The request is made here rather than through `createSocket`'s `recvBufferSize`: Node applies that option
    * inside the bind callback, where a refusal is thrown out of reach of this session and ends the process.
@@ -15716,7 +15742,8 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     if (granted >= RECEIVE_BUFFER_BYTES || this.receiveBufferReported)
       return;
     this.receiveBufferReported = true;
-    this.logger.warn(`[p2p] ${this.cfg.stationSn} UDP receive buffer below the ${RECEIVE_BUFFER_BYTES} bytes requested` + (granted > 0 ? ` (granted ${granted})` : " (request refused)") + `; 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}.`);
+    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. */
   async connect() {
@@ -16248,6 +16275,21 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.send(this.connectAddress, RequestMessageType.DATA, data);
     return true;
   }
+  /**
+   * The level-1 twin of {@link sendRawLevel2Bytes}: the plaintext `payload` sealed AES-128-ECB under the
+   * level-1 key, signCode 1 — the seal of the level-1 media start. Returns `false` when not connected.
+   */
+  sendRawLevel1Bytes(payload, channel, outerCmd) {
+    if (!this.connectAddress)
+      return false;
+    const data = Buffer.concat([
+      buildCommandHeader(this.seqNumber, outerCmd),
+      buildRawCommandPayload(encryptP2PData(paddingP2PData(payload), this.level1Key), channel, 1)
+    ]);
+    this.seqNumber = this.seqNumber + 1 & 65535;
+    this.send(this.connectAddress, RequestMessageType.DATA, data);
+    return true;
+  }
   /**
    * Stop the realtime media stream (`CMD_STOP_REALTIME_MEDIA`, 1004) on a camera `channel`, in the shape
    * its runtime topology takes, as {@link startLiveMedia} selects its start:
@@ -16809,11 +16851,13 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     if (advance > SEQUENCE_LOOKBACK) {
       if (65536 - advance <= STALE_RETRANSMIT_DEPTH)
         return;
-      if (this.pendingByDataType.has(dataType) && this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS)
+      if ((dataType === P2PDataType.VIDEO || 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);
+      if (dataType === P2PDataType.VIDEO)
+        this.emit("videoGap");
       this.lastSeqByType.set(dataType, seqNo);
       this.reassemble(dataType, msg.subarray(8));
       return;
@@ -16879,9 +16923,11 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    */
   abandonHole(dataType) {
     const held = this.reorderByType.get(dataType).held;
-    if (this.pendingByDataType.has(dataType) && this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS)
+    if ((dataType === P2PDataType.VIDEO || this.pendingByDataType.has(dataType)) && this.tracedDatagramGaps++ < MAX_TRACED_DATAGRAM_GAPS)
       this.trace({ phase: "datagram-gap", dataType });
     this.pendingByDataType.delete(dataType);
+    if (dataType === P2PDataType.VIDEO)
+      this.emit("videoGap");
     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);
@@ -17518,7 +17564,8 @@ var AccessUnitAssembler = class {
    * `decode` extracts the payload of a frame, whatever the stream's encryption: it is called for EVERY
    * frame, including a continuation, because a continuation carries its own wrapped key ahead of its share
    * of the payload (measured: 129 bytes beyond what its header declares, exactly as a unit's first frame
-   * carries).
+   * carries). A continuation without its matching open unit has no Annex-B start code and cannot be emitted
+   * as a complete unit, even if its repeated header says keyframe.
    */
   push(payload, decode) {
     const header = parseVideoFrameHeader(payload);
@@ -17538,6 +17585,8 @@ var AccessUnitAssembler = class {
       return [unitOf(open2.header, Buffer.concat(open2.chunks))];
     }
     this.discard();
+    if (!beginsAccessUnit(body))
+      return [];
     if (full) {
       this.open = { header, chunks: [body], carried: body.length };
       return [];
@@ -17891,6 +17940,12 @@ var LiveStream = class extends EventEmitter3 {
   lastCodec = "h264";
   /** Rebuilds an access unit the station split across several frames — see {@link AccessUnitAssembler}. */
   units = new AccessUnitAssembler((drop) => this.reportDroppedUnit(drop));
+  /** Whether a missing video datagram or incomplete unit invalidated the current reference chain. */
+  awaitingKeyframeAfterGap = false;
+  videoGapHandler = () => {
+    this.units.discard();
+    this.awaitingKeyframeAfterGap = true;
+  };
   /** The channel inbound media must be tagged with, once {@link acceptsMedia} trusts the station's tag. */
   mediaChannel;
   tracedFirstVideoCommand = false;
@@ -17933,6 +17988,7 @@ var LiveStream = class extends EventEmitter3 {
       return this;
     this.listening = true;
     this.session.on("data", this.handler);
+    this.session.on("videoGap", this.videoGapHandler);
     this.session.on("liveStartUnacknowledged", this.unackedHandler);
     this.sendStart();
     const keepAliveMs = this.opts.keepAliveMs ?? DEFAULT_KEEPALIVE_MS;
@@ -18030,6 +18086,8 @@ var LiveStream = class extends EventEmitter3 {
       return;
     this.listening = false;
     this.session.off("data", this.handler);
+    this.session.off("videoGap", this.videoGapHandler);
+    this.awaitingKeyframeAfterGap = false;
     this.session.off("liveStartUnacknowledged", this.unackedHandler);
     if (this.kaTimer)
       clearInterval(this.kaTimer);
@@ -18065,6 +18123,11 @@ var LiveStream = class extends EventEmitter3 {
     try {
       if (f.commandId === CMD_VIDEO_FRAME2) {
         for (const unit of this.units.push(f.data, (payload) => this.annexbOf(payload, f.signCode))) {
+          if (this.awaitingKeyframeAfterGap) {
+            if (!unit.keyframe)
+              continue;
+            this.awaitingKeyframeAfterGap = false;
+          }
           if (!this.tracedFirstVideoUnit) {
             this.tracedFirstVideoUnit = true;
             this.trace({ phase: "first-video-unit", keyframe: unit.keyframe });
@@ -18159,6 +18222,7 @@ var LiveStream = class extends EventEmitter3 {
    * otherwise silent in both directions: no frame reaches a consumer, and nothing states why.
    */
   reportDroppedUnit(drop) {
+    this.awaitingKeyframeAfterGap = true;
     const message = `[live] dropped an incomplete access unit (${drop.carried} bytes in ${drop.chunks} frame(s), tail never arrived, ${drop.count} so far)`;
     if (drop.count === 1)
       this.logger.warn(message);
@@ -21174,14 +21238,20 @@ var P2PCommandRouter = class _P2PCommandRouter {
     }
   }
   /**
-   * Restart a HomeBase. `RESTART_HUB` (1034) is a station-scalar on the broadcast channel 255: a
-   * level-2 frame whose body is `[u32 value][account_id padded]` — the same shape as the hub
-   * alarm-volume control. ✅ Wire-confirmed byte-exact from a capture of the app's own Restart
-   * (2026-08-03) and HW-tested: the captured frame carried value `0` and rebooted the hub. Replays
-   * like every other level-2 control, so a single dropped datagram doesn't lose it.
+   * Restart the station that owns `sn`'s P2P session. `RESTART_HUB` (1034) is a station-scalar on the
+   * broadcast channel 255 whose body is `[u32 value][account_id padded]`, value `0`. ✅ Wire-confirmed
+   * byte-exact as a level-2 frame from a capture of the app's own HomeBase Restart (2026-08-03).
+   *
+   * The seal follows the session, as {@link sendBySessionLevel} defines it: a keyed session takes the
+   * level-2 frame, a keyless one — a standalone camera, which never negotiates a key — the same body
+   * sealed level-1. Both are replayed {@link DIRECT_CMD_SENDS}× at 200ms, as every other unacknowledged
+   * control here is.
    */
   async rebootStation(sn) {
-    await this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel2Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB, 8));
+    await this.sendBySessionLevel(sn, {
+      l2: (resolved) => this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel2Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB, 8), resolved),
+      l1: (resolved) => this.replayLevel2Send(sn, `reboot ${sn}`, ({ session, accountId }) => session.sendRawLevel1Bytes(buildDirectBinaryBody(0, accountId), 255, P2P_ENVELOPE.RESTART_HUB), resolved)
+    });
   }
   /**
    * A {@link MediaProvider} bound to one serial — resolves the session then calls `p2p/media`.
@@ -22357,6 +22427,1237 @@ var P2PCommandRouter = class _P2PCommandRouter {
   }
 };
 
+// dist/transport/rtc/session.js
+import { EventEmitter as EventEmitter9 } from "node:events";
+
+// dist/transport/rtc/peer.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 PortalLinkType = {
+  /** Command channel: requests out, acknowledgements back. */
+  COMMAND: 1,
+  /** Station-originated frames: pushes, notify payloads, control results. */
+  NOTIFY: 3
+};
+function encodeLe(value, width) {
+  const buf = Buffer.alloc(width);
+  let v = value >>> 0;
+  for (let i = 0; i < width; i++) {
+    buf[i] = v & 255;
+    v >>>= 8;
+  }
+  return buf;
+}
+function buildPortalHeader(commandId, paramLength, channel, segment, isResponse = 0, devType = 2) {
+  const header = Buffer.alloc(PORTAL_HEADER_LENGTH);
+  MAGIC2.copy(header, 0);
+  encodeLe(commandId, 2).copy(header, 4);
+  encodeLe(paramLength, 4).copy(header, 6);
+  header[10] = 0;
+  header[11] = segment & 255;
+  header[12] = channel & 255;
+  header[13] = 0;
+  header[14] = isResponse & 255;
+  header[15] = devType & 255;
+  return header;
+}
+function parsePortalHeader(buf) {
+  if (buf.length < PORTAL_HEADER_LENGTH || buf.subarray(0, 4).compare(MAGIC2) !== 0)
+    return void 0;
+  return {
+    commandId: buf.readUInt16LE(4),
+    paramLength: buf.readUInt32LE(6),
+    segment: buf[11],
+    channel: buf[12],
+    isResponse: buf[14],
+    devType: buf[15]
+  };
+}
+function isPortalPacket(buf) {
+  return buf.length >= PORTAL_HEADER_LENGTH && buf.subarray(0, 4).compare(MAGIC2) === 0;
+}
+function buildPortalPacket(req) {
+  const body = Buffer.from(JSON.stringify(req.payload), "utf8");
+  const header = buildPortalHeader(req.commandId, body.length, req.channel, req.segment, req.isResponse ?? 0, req.devType ?? 2);
+  return Buffer.concat([header, body]);
+}
+function parseJsonBody(buf) {
+  let text2 = buf.toString("utf8");
+  while (text2.endsWith("\0"))
+    text2 = text2.slice(0, -1);
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function parsePortalPacket(buf, linkType = PortalLinkType.COMMAND) {
+  const header = parsePortalHeader(buf);
+  if (!header)
+    return void 0;
+  const body = buf.subarray(PORTAL_HEADER_LENGTH, PORTAL_HEADER_LENGTH + header.paramLength);
+  if (linkType === PortalLinkType.NOTIFY) {
+    const data = parseJsonBody(body);
+    const cmd = typeof data === "object" && data !== null && "cmd" in data ? Number(data.cmd) : void 0;
+    return {
+      commandId: header.commandId,
+      channel: header.channel,
+      segment: header.segment,
+      isResponse: header.isResponse,
+      linkType,
+      cmd,
+      data
+    };
+  }
+  return {
+    commandId: header.commandId,
+    channel: header.channel,
+    segment: header.segment,
+    isResponse: header.isResponse,
+    linkType,
+    errCode: body.length >= 4 ? body.readInt32LE(0) : -1,
+    data: body.length > 4 ? parseJsonBody(body.subarray(4)) : void 0
+  };
+}
+var SegmentCounter = class {
+  current = 0;
+  next() {
+    this.current = this.current + 1 & 255;
+    if (this.current === 0)
+      this.current = 1;
+    return this.current;
+  }
+};
+
+// dist/transport/rtc/ptcs-framer.js
+var MAGIC3 = Buffer.from("PTCS", "ascii");
+var PTCS_HEADER_LENGTH = 28;
+var PTCS_DEFAULT_PAYLOAD_BYTES = 1e3;
+var FLAG_BASE = 16384;
+var FLAG_LAST = 1024;
+var LENGTH_MASK = 1023;
+var PtcsChannel = {
+  COMMAND: 0,
+  NOTIFY: 2
+};
+function linkTypeForChannel(channel) {
+  return channel === PtcsChannel.NOTIFY ? PortalLinkType.NOTIFY : PortalLinkType.COMMAND;
+}
+var PTCS_STALE_MS = 15e3;
+function parsePtcsHeader(packet) {
+  if (packet.length < PTCS_HEADER_LENGTH || packet.subarray(0, 4).compare(MAGIC3) !== 0)
+    return void 0;
+  const flags = packet.readUInt16LE(18);
+  return {
+    channel: packet[5],
+    sequence: packet.readUInt16LE(6),
+    frameId: packet.readUInt32LE(8),
+    frameLength: packet.readUInt32LE(12),
+    index: packet.readUInt16LE(16),
+    last: (flags & FLAG_LAST) !== 0,
+    payloadLength: flags & LENGTH_MASK
+  };
+}
+function packetize(frame, opts) {
+  const size = opts.payloadBytes ?? PTCS_DEFAULT_PAYLOAD_BYTES;
+  if (size <= 0 || size > LENGTH_MASK)
+    throw new RangeError(`PTCS payload size ${size} out of range`);
+  const channel = opts.channel ?? PtcsChannel.COMMAND;
+  const count2 = Math.max(1, Math.ceil(frame.length / size));
+  const sequence = (opts.sequence ?? 0) & 65535;
+  const packets = [];
+  for (let i = 0; i < count2; i++) {
+    const chunk = frame.subarray(i * size, Math.min(frame.length, (i + 1) * size));
+    const last = i === count2 - 1;
+    const packet = Buffer.alloc(PTCS_HEADER_LENGTH + size);
+    MAGIC3.copy(packet, 0);
+    packet[4] = 3;
+    packet[5] = channel & 255;
+    packet.writeUInt16LE(sequence, 6);
+    packet.writeUInt32LE(opts.frameId >>> 0, 8);
+    packet.writeUInt32LE(frame.length >>> 0, 12);
+    packet.writeUInt16LE(i, 16);
+    packet.writeUInt16LE(FLAG_BASE | (last ? FLAG_LAST : 0) | chunk.length, 18);
+    chunk.copy(packet, PTCS_HEADER_LENGTH);
+    packets.push(packet);
+  }
+  return packets;
+}
+var PtcsReassembler = class {
+  onFrame;
+  now;
+  partials = /* @__PURE__ */ new Map();
+  constructor(onFrame, now2 = Date.now) {
+    this.onFrame = onFrame;
+    this.now = now2;
+  }
+  push(packet) {
+    const h = parsePtcsHeader(packet);
+    if (!h)
+      return false;
+    const body = packet.subarray(PTCS_HEADER_LENGTH, PTCS_HEADER_LENGTH + h.payloadLength);
+    if (body.length !== h.payloadLength)
+      return false;
+    const key = `${h.channel}:${h.frameId}`;
+    const now2 = this.now();
+    let p = this.partials.get(key);
+    if (!p) {
+      p = { channel: h.channel, frameLength: h.frameLength, chunks: /* @__PURE__ */ new Map(), touched: now2 };
+      this.partials.set(key, p);
+    }
+    p.touched = now2;
+    p.chunks.set(h.index, Buffer.from(body));
+    if (h.last)
+      p.lastIndex = h.index;
+    if (p.lastIndex === void 0)
+      return true;
+    let total = 0;
+    const parts = [];
+    for (let i = 0; i <= p.lastIndex; i++) {
+      const c = p.chunks.get(i);
+      if (!c)
+        return true;
+      parts.push(c);
+      total += c.length;
+    }
+    this.partials.delete(key);
+    if (total !== p.frameLength)
+      return false;
+    this.onFrame(Buffer.concat(parts, total), p.channel);
+    return true;
+  }
+  /** Drop frames that stopped arriving; call periodically. */
+  expire() {
+    const now2 = this.now();
+    for (const [key, p] of this.partials) {
+      if (now2 - p.touched > PTCS_STALE_MS)
+        this.partials.delete(key);
+    }
+  }
+};
+function frameIdClock(now2 = Date.now) {
+  let last = 0;
+  return () => {
+    let id = now2() >>> 0;
+    if (id <= last)
+      id = last + 1 >>> 0;
+    last = id;
+    return id;
+  };
+}
+var PtcsFramer = class {
+  onWire;
+  onFrame;
+  reassembler;
+  sweep;
+  ready = false;
+  nextFrameId = frameIdClock();
+  sequence = 0;
+  /** Arm the two callbacks; `sendFrame` may be called from here on. */
+  init(onWirePacket, onFrame) {
+    this.onWire = onWirePacket;
+    this.onFrame = onFrame;
+    this.reassembler = new PtcsReassembler((frame, channel) => this.onFrame?.(frame, linkTypeForChannel(channel)));
+    this.sweep = setInterval(() => this.reassembler?.expire(), 1e3);
+    this.sweep.unref?.();
+    this.ready = true;
+  }
+  isReady() {
+    return this.ready;
+  }
+  sendFrame(portalPacket) {
+    if (!this.ready)
+      throw new Error("PTCS framer not initialised");
+    const packets = packetize(portalPacket, { frameId: this.nextFrameId(), sequence: this.sequence });
+    this.sequence = this.sequence + 1 & 65535;
+    for (const packet of packets)
+      this.onWire?.(packet);
+  }
+  recvPacket(wirePacket) {
+    if (!this.ready)
+      return;
+    if (isPortalPacket(wirePacket)) {
+      this.onFrame?.(wirePacket, PortalLinkType.COMMAND);
+      return;
+    }
+    this.reassembler?.push(wirePacket);
+  }
+  destroy() {
+    this.ready = false;
+    if (this.sweep)
+      clearInterval(this.sweep);
+    this.sweep = void 0;
+    this.reassembler = void 0;
+    this.onWire = void 0;
+    this.onFrame = void 0;
+  }
+};
+
+// dist/transport/rtc/scall-sdp.js
+var HUB_SDP_MID = "2";
+var ANKER_MAX_MESSAGE_SIZE = 262144;
+function scallJsonToSdp(json, now2 = Date.now) {
+  let sdp = "";
+  sdp += "v=0\r\n";
+  sdp += `o=- ${Math.floor(now2())} 1 IN IP4 127.0.0.1\r
+`;
+  sdp += "s=Anker Webrtc Stream\r\n";
+  sdp += "t=0 0\r\n";
+  sdp += `a=group:BUNDLE ${HUB_SDP_MID}\r
+`;
+  sdp += "a=msid-semantic: WMS\r\n";
+  sdp += "m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n";
+  sdp += "c=IN IP4 127.0.0.1\r\n";
+  sdp += `a=mid:${HUB_SDP_MID}\r
+`;
+  sdp += "a=ice-options:trickle\r\n";
+  if (json.ice?.ufrag)
+    sdp += `a=ice-ufrag:${json.ice.ufrag}\r
+`;
+  if (json.ice?.pwd)
+    sdp += `a=ice-pwd:${json.ice.pwd}\r
+`;
+  if (json.ice?.fingerprint) {
+    const fp = json.ice.fingerprint.replace(/(.{2})(?=.)/g, "$1:");
+    sdp += `a=fingerprint:${json.ice.fingerprint_type ?? "sha-256"} ${fp}\r
+`;
+  }
+  sdp += `a=setup:${json.setup ?? "actpass"}\r
+`;
+  sdp += "a=sctp-port:5000\r\n";
+  sdp += `a=max-message-size:${ANKER_MAX_MESSAGE_SIZE}\r
+`;
+  for (const c of json.candidate ?? [])
+    sdp += `a=candidate:${c}\r
+`;
+  return sdp;
+}
+function sdpToScallJson(sdp) {
+  const json = { ice: { ufrag: "", pwd: "", fingerprint: "" } };
+  const setup = sdp.match(/a=setup:([^\r\n]+)/)?.[1];
+  if (setup && setup !== "actpass")
+    json.setup = setup;
+  const ufrag = sdp.match(/a=ice-ufrag:([^\r\n]+)/)?.[1];
+  if (ufrag)
+    json.ice.ufrag = ufrag;
+  const pwd = sdp.match(/a=ice-pwd:([^\r\n]+)/)?.[1];
+  if (pwd)
+    json.ice.pwd = pwd;
+  const fp = sdp.match(/a=fingerprint:([^\s]+)\s+([^\r\n]+)/);
+  if (fp?.[2]) {
+    json.ice.fingerprint_type = fp[1];
+    json.ice.fingerprint = fp[2].replace(/:/g, "");
+  }
+  const candidates = [];
+  for (const line of sdp.split(/\r\n|\r|\n/)) {
+    const m = line.match(/^a=candidate:(.+)/);
+    if (m?.[1])
+      candidates.push(m[1]);
+  }
+  if (candidates.length)
+    json.candidate = candidates;
+  return json;
+}
+function iceCandidateType(candidate) {
+  return candidate.match(/typ (\w+)/)?.[1] ?? "unknown";
+}
+function pinMaxMessageSize(sdp) {
+  return sdp.replace(/a=max-message-size:\d+/g, `a=max-message-size:${ANKER_MAX_MESSAGE_SIZE}`);
+}
+function forceDtlsRole(sdp, role) {
+  if (/a=setup:(active|passive|actpass)/.test(sdp))
+    return sdp.replace(/a=setup:(active|passive|actpass)/g, `a=setup:${role}`);
+  return sdp.replace(/(m=application[^\r\n]*\r?\n)/, `$1a=setup:${role}\r
+`);
+}
+function toWireCandidate(candidate) {
+  return candidate.trim().replace(/^a=/, "");
+}
+
+// dist/transport/rtc/peer.js
+var DATA_CHANNEL_LABELS = ["WebrtcDataChannel", "audio", "idr", "video", "notify", "download"];
+var COMMAND_CHANNEL = DATA_CHANNEL_LABELS[0];
+var DATA_CHANNEL_IDS = {
+  WebrtcDataChannel: 0,
+  audio: 2,
+  idr: 4,
+  video: 6,
+  notify: 8,
+  download: 10
+};
+function turnServers(turn) {
+  const both = (hostname, port) => [
+    { hostname, port, username: turn.turn_user, password: turn.turn_password, relayType: "TurnUdp" },
+    { hostname, port, username: turn.turn_user, password: turn.turn_password, relayType: "TurnTcp" }
+  ];
+  const servers = both(turn.turn_addr, turn.turn_port);
+  if (turn.alt_turn_addr && turn.alt_turn_port)
+    servers.push(...both(turn.alt_turn_addr, turn.alt_turn_port));
+  return servers;
+}
+var UNBUILT_ARCHES = /* @__PURE__ */ new Set(["arm", "ia32"]);
+async function loadNativePeerFactory() {
+  let ndc;
+  try {
+    ndc = await import("node-datachannel");
+  } catch (err) {
+    const message = UNBUILT_ARCHES.has(process.arch) ? `the WebRTC transport for a HomeBase S1 Pro (T9000) needs 'node-datachannel', which has no build for ${process.arch}; a 64-bit OS is needed to drive a T9000` : "the WebRTC transport for a HomeBase S1 Pro (T9000) needs the optional peer dependency 'node-datachannel' (`npm install node-datachannel`)";
+    throw new Error(message, { cause: err });
+  }
+  return (name, config) => new ndc.PeerConnection(name, config);
+}
+var ANSWER_TIMEOUT_MS = 15e3;
+var RtcPeer = class extends EventEmitter7 {
+  opts;
+  pc;
+  channels = /* @__PURE__ */ new Map();
+  framer;
+  wireTally = /* @__PURE__ */ new Map();
+  commandOpen = false;
+  remoteSet = false;
+  handlingOffer = false;
+  channelsCreated = false;
+  gatheringDone = false;
+  /** Set by the framer's wire callback when the native channel refused a packet mid-send. */
+  wireSendFailed = false;
+  pending = [];
+  localAnswer;
+  logger;
+  constructor(opts = {}) {
+    super();
+    this.opts = opts;
+    this.logger = opts.logger ?? noopLogger;
+  }
+  /** Create the native peer on the relay the hub granted in `scall 100`. */
+  async init(turn) {
+    if (this.pc)
+      return;
+    const createPeer = this.opts.createPeer ?? await loadNativePeerFactory();
+    const config = {
+      iceServers: turnServers(turn),
+      iceTransportPolicy: "relay",
+      maxMessageSize: ANKER_MAX_MESSAGE_SIZE,
+      enableIceTcp: true
+    };
+    const pc = createPeer("eufy-sdk", config);
+    this.pc = pc;
+    pc.onLocalDescription((sdp, type) => {
+      if (String(type).toLowerCase() === "answer" && this.localAnswer) {
+        clearTimeout(this.localAnswer.timer);
+        this.localAnswer.resolve(sdp);
+        this.localAnswer = void 0;
+      }
+    });
+    pc.onLocalCandidate((candidate) => {
+      if (!candidate)
+        return;
+      if (!this.acceptsCandidate(candidate))
+        return;
+      this.emit("iceCandidate", candidate);
+    });
+    pc.onGatheringStateChange((state) => {
+      if (state === "complete" && !this.gatheringDone) {
+        this.gatheringDone = true;
+        this.emit("iceGatheringComplete");
+      }
+    });
+    pc.onStateChange((state) => {
+      this.logger.debug(`[rtc] peer state ${state}`);
+      this.emit("connectionState", state);
+    });
+    pc.onDataChannel((dc) => this.wireChannel(dc.getLabel(), dc));
+  }
+  /**
+   * The hub offered: apply the offer, declare the channels, return the answer SDP to signal back.
+   *
+   * The offer is pinned to `passive` before it is applied, so the native peer has one legal answer,
+   * `active`: the role is fixed where it is decided, since rewriting the answer afterwards would change
+   * only what is announced. The offer goes in before the channels are declared: `createDataChannel` on
+   * a peer without a remote description starts its own negotiation and leaves it in `have-local-offer`.
+   * The data channels need no m-line of their own; the offer's SCTP m-line carries them. Only an ANSWER
+   * is taken as the local description: one read in `have-local-offer` is an offer.
+   */
+  async handleRemoteOffer(offerSdp) {
+    const pc = this.pc;
+    if (!pc)
+      throw new Error("RTC peer not initialised");
+    if (this.handlingOffer)
+      throw new Error("RTC peer already handling an offer");
+    this.handlingOffer = true;
+    try {
+      const offer = forceDtlsRole(offerSdp, "passive");
+      const answerWait = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          this.localAnswer = void 0;
+          reject(new Error("timed out waiting for the local SDP answer"));
+        }, ANSWER_TIMEOUT_MS);
+        this.localAnswer = { resolve, reject, timer };
+      });
+      pc.setRemoteDescription(offer, "offer");
+      this.remoteSet = true;
+      this.createChannels();
+      const local = pc.localDescription();
+      let answer = String(local?.type ?? "").toLowerCase() === "answer" ? local?.sdp ?? "" : "";
+      if (!answer)
+        answer = await answerWait;
+      else if (this.localAnswer) {
+        clearTimeout(this.localAnswer.timer);
+        this.localAnswer = void 0;
+      }
+      this.flushPending();
+      return pinMaxMessageSize(answer);
+    } finally {
+      this.handlingOffer = false;
+    }
+  }
+  addRemoteCandidate(candidate) {
+    if (!this.pc)
+      return;
+    if (!this.acceptsCandidate(candidate))
+      return;
+    if (!this.remoteSet || this.handlingOffer) {
+      this.pending.push(candidate);
+      return;
+    }
+    this.addNow(candidate);
+  }
+  /**
+   * 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.
+   */
+  sendCommand(portalPacket) {
+    const dc = this.channels.get(COMMAND_CHANNEL);
+    if (!dc?.isOpen() || !this.commandOpen || !this.framer?.isReady())
+      return false;
+    this.wireSendFailed = false;
+    try {
+      this.framer.sendFrame(portalPacket);
+    } catch (e) {
+      this.logger.warn(`[rtc] command send failed: ${e instanceof Error ? e.message : String(e)}`);
+      return false;
+    }
+    return !this.wireSendFailed;
+  }
+  /** Tear the peer down. A pending answer is rejected, so a `handleRemoteOffer` in flight settles. */
+  close() {
+    this.framer?.destroy();
+    this.framer = void 0;
+    if (this.localAnswer) {
+      clearTimeout(this.localAnswer.timer);
+      const pending = this.localAnswer;
+      this.localAnswer = void 0;
+      pending.reject(new Error("RTC peer closed while waiting for the local SDP answer"));
+    }
+    this.commandOpen = false;
+    this.gatheringDone = false;
+    this.pc?.close();
+    this.pc = void 0;
+    this.channels.clear();
+    this.channelsCreated = false;
+    this.remoteSet = false;
+    this.pending.length = 0;
+  }
+  acceptsCandidate(candidate) {
+    return iceCandidateType(candidate) === "relay";
+  }
+  createChannels() {
+    if (!this.pc || this.channelsCreated)
+      return;
+    this.channelsCreated = true;
+    for (const label of DATA_CHANNEL_LABELS) {
+      const dc = this.pc.createDataChannel(label, { id: DATA_CHANNEL_IDS[label], unordered: false });
+      this.wireChannel(label, dc);
+    }
+  }
+  /**
+   * Wire one data channel. Every channel feeds the framer once the command channel has opened it; a
+   * message before that has nothing to reassemble into and is dropped.
+   */
+  wireChannel(label, dc) {
+    if (this.channels.has(label))
+      return;
+    this.channels.set(label, dc);
+    dc.onOpen(() => {
+      this.logger.debug(`[rtc] data channel open ${label}`);
+      if (label !== COMMAND_CHANNEL)
+        return;
+      if (!this.framer) {
+        const framer = new PtcsFramer();
+        framer.init((packet) => {
+          if (!dc.isOpen() || !dc.sendMessageBinary(packet))
+            this.wireSendFailed = true;
+        }, (frame, linkType) => this.emit("data", frame, linkType));
+        this.framer = framer;
+      }
+      this.commandOpen = true;
+      this.emit("commandChannelOpen");
+    });
+    dc.onClosed(() => {
+      this.logger.debug(`[rtc] data channel closed ${label}`);
+      if (label !== COMMAND_CHANNEL)
+        return;
+      const wasOpen = this.commandOpen;
+      this.commandOpen = false;
+      if (wasOpen)
+        this.emit("commandChannelClosed");
+    });
+    dc.onError((err) => this.emit("error", new Error(`RTC data channel ${label}: ${err}`)));
+    dc.onMessage((msg) => {
+      const buf = typeof msg === "string" ? Buffer.from(msg) : Buffer.isBuffer(msg) ? msg : Buffer.from(msg);
+      const n = (this.wireTally.get(label) ?? 0) + 1;
+      this.wireTally.set(label, n);
+      if (n <= 3 || n % 100 === 0) {
+        this.logger.debug(`[rtc] wire ${label} #${n} ${buf.length}B ${buf.subarray(0, 8).toString("hex")}`);
+      }
+      this.framer?.recvPacket(buf);
+    });
+  }
+  addNow(candidate) {
+    try {
+      this.pc?.addRemoteCandidate(candidate, HUB_SDP_MID);
+    } catch (e) {
+      this.logger.warn(`[rtc] addRemoteCandidate failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  flushPending() {
+    const queued = this.pending.splice(0);
+    for (const c of queued)
+      this.addNow(c);
+  }
+};
+
+// dist/transport/rtc/signaling.js
+import { EventEmitter as EventEmitter8 } 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";
+var PORTAL_ORIGIN = "https://security.eufy.com";
+var SIGNALING_KEEPALIVE_MS = 25e3;
+var SIGNALING_CONNECT_TIMEOUT_MS = 15e3;
+var SOURCE = "WEB";
+function sessionAccount(channelId, adminUserId, ts, authToken) {
+  return createHmac3("sha256", authToken).update(`${channelId}${adminUserId}${ts}`).digest("hex");
+}
+var WS_OPEN = 1;
+var defaultSocket = (url, init) => new WebSocket(url, {
+  protocols: init.protocols,
+  headers: { Origin: init.origin }
+});
+var RtcSignalingClient = class extends EventEmitter8 {
+  opts;
+  ws;
+  sign;
+  keepalive;
+  wsUrl;
+  signUrl;
+  wsRegion;
+  fetchImpl;
+  createSocket;
+  logger;
+  now;
+  makeMsgId;
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    const prefix = (opts.shard.split("-")[0] || "us").toLowerCase();
+    const smartHost = prefix === "us" ? "security-smart.eufylife.com" : `security-smart-${prefix}.eufylife.com`;
+    this.wsUrl = `wss://${smartHost}${RTC_WS_PATH}`;
+    this.signUrl = `https://${smartHost}${RTC_SIGN_PATH}`;
+    this.wsRegion = prefix.toUpperCase();
+    this.fetchImpl = opts.fetch ?? fetch;
+    this.createSocket = opts.createSocket ?? defaultSocket;
+    this.logger = opts.logger ?? noopLogger;
+    this.now = opts.now ?? Date.now;
+    this.makeMsgId = opts.makeMsgId ?? (() => randomUUID2().replace(/-/g, ""));
+  }
+  get isOpen() {
+    return this.ws?.readyState === WS_OPEN;
+  }
+  /** Step 1: the sign blob the socket and every auth message carry. A non-JSON body is reported by status. */
+  async fetchSign() {
+    const res = await this.fetchImpl(this.signUrl, {
+      headers: {
+        "Web-Country": this.opts.country.toUpperCase(),
+        "X-Auth-Token": this.opts.authToken,
+        "App-Name": "eufy_mega",
+        "Model-Type": "WEB",
+        GToken: this.opts.gtoken,
+        Origin: PORTAL_ORIGIN
+      }
+    });
+    const body = await res.json().catch(() => ({})) ?? {};
+    if (!res.ok || body.code !== 0 || !body.data) {
+      throw new Error(`RTC sign for ${this.opts.stationSn} refused: HTTP ${res.status} code ${body.code ?? "?"} ${body.msg ?? ""}`.trim());
+    }
+    this.sign = body.data;
+    return body.data;
+  }
+  /**
+   * Step 2: open the socket and send the first auth; resolves on `open`. A socket that closes or errors
+   * before it ever opened rejects, so the call always settles.
+   */
+  async connect() {
+    if (this.ws)
+      return;
+    const sign = this.sign ?? await this.fetchSign();
+    const auth = {
+      region: this.wsRegion,
+      type: "NVR",
+      sn: this.opts.stationSn,
+      token: this.opts.authToken,
+      gtoken: this.opts.gtoken,
+      sign,
+      appName: "eufy_mega",
+      modelType: "WEB"
+    };
+    const protocols = ["v1", Buffer.from(JSON.stringify(auth)).toString("base64url")];
+    this.logger.debug(`[rtc] ${this.opts.stationSn} signalling connect ${this.wsUrl}`);
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`RTC signalling connect timeout after ${SIGNALING_CONNECT_TIMEOUT_MS}ms`));
+        this.close();
+      }, SIGNALING_CONNECT_TIMEOUT_MS);
+      const ws = this.createSocket(this.wsUrl, { protocols, origin: PORTAL_ORIGIN });
+      this.ws = ws;
+      let opened = false;
+      ws.addEventListener("open", () => {
+        opened = true;
+        clearTimeout(timer);
+        this.sendAuth(sign);
+        this.startKeepalive();
+        this.emit("open");
+        resolve();
+      });
+      ws.addEventListener("message", (ev) => {
+        void this.handleWireMessage(ev.data);
+      });
+      ws.addEventListener("close", (ev) => {
+        clearTimeout(timer);
+        this.stopKeepalive();
+        this.ws = void 0;
+        const code = ev.code ?? 1006;
+        const reason = ev.reason ?? "";
+        this.logger.debug(`[rtc] ${this.opts.stationSn} signalling closed ${code} ${reason}`);
+        if (!opened)
+          reject(new Error(`RTC signalling closed before open: ${code} ${reason}`.trim()));
+        this.emit("close", code, reason);
+      });
+      ws.addEventListener("error", (ev) => {
+        clearTimeout(timer);
+        const detail = ev ?? {};
+        const cause = detail.error?.message ?? detail.error?.code ?? detail.message ?? "";
+        reject(new Error(`RTC signalling socket error${cause ? ": " + cause : ""}`));
+      });
+    });
+  }
+  /** `action 1`, also what keeps the socket alive when re-sent. */
+  sendAuth(sign) {
+    const s = sign ?? this.sign;
+    if (!s)
+      throw new Error("RTC signalling: no sign to authenticate with");
+    this.sendEnvelope("0", {
+      code: 200,
+      action: 1,
+      data: s,
+      sn: this.opts.stationSn,
+      source: SOURCE,
+      ts: Math.floor(this.now() / 1e3)
+    });
+  }
+  /**
+   * `action 3`, a session message on channel 0, the hub's own session; `scall` opens the negotiation.
+   * `subSn` is empty for the hub's session.
+   */
+  sendSession(dataType, payload = {}) {
+    const channelId = 0;
+    const ts = Math.floor(this.now() / 1e3);
+    const inner = {
+      code: 200,
+      action: 3,
+      sessionId: this.sign,
+      sn: this.opts.stationSn,
+      subSn: "",
+      channelId,
+      isResponse: 0,
+      dataType,
+      source: SOURCE,
+      ts,
+      data: JSON.stringify({
+        timestamp: ts,
+        account: sessionAccount(channelId, this.opts.adminUserId, ts, this.opts.authToken),
+        ...payload
+      })
+    };
+    this.sendEnvelope(`${this.opts.authToken}_${this.makeMsgId()}`, inner);
+  }
+  sendCall() {
+    this.sendSession("scall");
+  }
+  sendAck() {
+    this.sendSession("ack");
+  }
+  /** The SDP answer, as scall JSON text, in an `info`. */
+  sendInfoSdp(scallJson) {
+    this.sendSession("info", { sdp: scallJson });
+  }
+  /** Trickle a candidate on the session's channel, like its SDP answer. An empty candidate ends them. */
+  sendInfoCandidate(candidate) {
+    this.sendSession("info", { candidate });
+  }
+  sendHangup() {
+    this.sendSession("hangup");
+  }
+  close() {
+    this.stopKeepalive();
+    const ws = this.ws;
+    this.ws = void 0;
+    try {
+      ws?.close();
+    } catch {
+    }
+  }
+  startKeepalive() {
+    this.stopKeepalive();
+    this.keepalive = setInterval(() => {
+      if (!this.isOpen)
+        return;
+      try {
+        this.sendAuth();
+      } catch (e) {
+        this.logger.warn(`[rtc] ${this.opts.stationSn} signalling keepalive failed`, e);
+      }
+    }, SIGNALING_KEEPALIVE_MS);
+    this.keepalive.unref?.();
+  }
+  stopKeepalive() {
+    if (this.keepalive)
+      clearInterval(this.keepalive);
+    this.keepalive = void 0;
+  }
+  sendEnvelope(msgid, inner) {
+    if (!this.isOpen || !this.ws)
+      throw new Error("RTC signalling not connected");
+    const envelope = { msgid, data: JSON.stringify(inner) };
+    this.ws.send(JSON.stringify(envelope));
+  }
+  async handleWireMessage(raw) {
+    let text2;
+    if (typeof raw === "string")
+      text2 = raw;
+    else if (Buffer.isBuffer(raw))
+      text2 = raw.toString("utf8");
+    else if (raw instanceof ArrayBuffer)
+      text2 = Buffer.from(raw).toString("utf8");
+    else if (typeof raw?.text === "function")
+      text2 = await raw.text();
+    else
+      return;
+    let envelope;
+    let inner;
+    try {
+      envelope = JSON.parse(text2);
+      if (typeof envelope?.data !== "string")
+        return;
+      inner = JSON.parse(envelope.data);
+    } catch {
+      return;
+    }
+    this.emit("message", inner, envelope);
+  }
+};
+
+// dist/transport/rtc/session.js
+var AUTH_TIMEOUT_MS = 15e3;
+var RtcSession = class extends EventEmitter9 {
+  opts;
+  signaling;
+  peer;
+  logger;
+  turn;
+  authOk = false;
+  authWaiter;
+  connected = false;
+  closed = false;
+  closeAnnounced = false;
+  sdpHandled = false;
+  chain = Promise.resolve();
+  constructor(opts) {
+    super();
+    this.opts = opts;
+    this.logger = opts.logger ?? noopLogger;
+    this.signaling = (opts.createSignaling ?? ((o) => new RtcSignalingClient(o)))(opts);
+    this.peer = (opts.createPeer ?? ((o) => new RtcPeer(o)))({ logger: this.logger, ...opts.peer });
+    this.signaling.on("message", (inner) => {
+      this.chain = this.chain.then(() => this.onSignaling(inner)).catch((e) => {
+        this.emit("error", e instanceof Error ? e : new Error(String(e)));
+      });
+    });
+    this.signaling.on("close", () => {
+      this.connected = false;
+      this.announceClose();
+    });
+    this.signaling.on("error", (e) => this.emit("error", e));
+    this.peer.on("iceCandidate", (c) => this.signaling.sendInfoCandidate(toWireCandidate(c)));
+    this.peer.on("iceGatheringComplete", () => this.signaling.sendInfoCandidate(""));
+    this.peer.on("commandChannelOpen", () => {
+      if (this.connected)
+        return;
+      this.connected = true;
+      this.logger.debug(`[rtc] ${this.opts.stationSn} command channel open`);
+      this.emit("connected");
+    });
+    this.peer.on("commandChannelClosed", () => {
+      if (!this.connected)
+        return;
+      this.connected = false;
+      this.logger.debug(`[rtc] ${this.opts.stationSn} command channel closed`);
+      this.announceClose();
+    });
+    this.peer.on("connectionState", (state) => {
+      if ((state === "failed" || state === "closed") && this.connected) {
+        this.connected = false;
+        this.announceClose();
+      }
+    });
+    this.peer.on("error", (e) => this.emit("error", e));
+    this.peer.on("data", (frame, linkType) => this.emit("commandData", frame, linkType));
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  /**
+   * Start the sequence; resolves once `scall` is sent. `connected` fires when the channel opens. A session
+   * closed by the time the sign fetch or the auth completes rejects instead of opening the socket or
+   * placing the call.
+   */
+  async connect() {
+    await this.signaling.fetchSign();
+    if (this.closed)
+      throw new Error("RTC session closed before the call was placed");
+    await this.signaling.connect();
+    await this.waitForAuth();
+    if (this.closed)
+      throw new Error("RTC session closed before the call was placed");
+    this.logger.debug(`[rtc] ${this.opts.stationSn} authenticated \u2014 scall`);
+    this.signaling.sendCall();
+  }
+  /** Send one portal packet; false when the command channel isn't open. */
+  sendCommand(portalPacket) {
+    return this.peer.sendCommand(portalPacket);
+  }
+  /**
+   * 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.
+   */
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.connected = false;
+    try {
+      if (this.signaling.isOpen)
+        this.signaling.sendHangup();
+    } catch {
+    }
+    this.signaling.close();
+    this.peer.close();
+    this.settleAuth(new Error("RTC session closed while waiting for signalling auth"));
+    this.announceClose();
+  }
+  announceClose() {
+    if (this.closeAnnounced)
+      return;
+    this.closeAnnounced = true;
+    this.emit("close");
+  }
+  waitForAuth() {
+    if (this.authOk)
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.authWaiter = void 0;
+        reject(new Error("RTC signalling auth timeout"));
+      }, AUTH_TIMEOUT_MS);
+      this.authWaiter = { resolve, reject, timer };
+    });
+  }
+  /** Settle a pending auth wait: resolve it, or reject it with `err`; either way its timer stops. */
+  settleAuth(err) {
+    const waiter = this.authWaiter;
+    if (!waiter)
+      return;
+    this.authWaiter = void 0;
+    clearTimeout(waiter.timer);
+    if (err)
+      waiter.reject(err);
+    else
+      waiter.resolve();
+  }
+  async onSignaling(inner) {
+    if (inner.action === 1 && inner.code === 200) {
+      this.authOk = true;
+      this.settleAuth();
+    }
+    if (!inner.data)
+      return;
+    let payload;
+    try {
+      payload = JSON.parse(inner.data);
+    } catch {
+      return;
+    }
+    switch (inner.dataType) {
+      case "scall":
+      case "call":
+        await this.onCall(payload);
+        return;
+      case "info":
+        await this.onInfo(payload);
+        return;
+      case "hangup":
+        this.logger.debug(`[rtc] ${this.opts.stationSn} hub hung up`);
+        return;
+      default:
+        return;
+    }
+  }
+  /** A `scall` status: `100` grants the relay, `200` is acknowledged, `486`/`408` fail the session. */
+  async onCall(payload) {
+    if (this.closed)
+      return;
+    const status = payload.status;
+    if (status === 100 && payload.turn) {
+      this.turn = payload.turn;
+      await this.peer.init(payload.turn);
+      return;
+    }
+    if (status === 200) {
+      this.signaling.sendAck();
+      return;
+    }
+    if (status === 486 || status === 408) {
+      this.emit("error", new Error(`RTC ${this.opts.stationSn} scall answered ${status}`));
+      this.close();
+    }
+  }
+  /**
+   * An `info`: trickle ICE, in either of the two shapes the hub sends, or the hub's SDP offer. The offer
+   * is answered only once a TURN grant is in: the peer is relay-only, so an offer ahead of `scall 100`
+   * is reported and left unanswered.
+   */
+  async onInfo(payload) {
+    if (this.closed)
+      return;
+    if (payload.format === "CANDIDATE") {
+      if (payload.value)
+        this.peer.addRemoteCandidate(payload.value);
+      return;
+    }
+    if (payload.candidate !== void 0) {
+      if (payload.candidate)
+        this.peer.addRemoteCandidate(payload.candidate);
+      return;
+    }
+    const sdpText = payload.value ?? payload.sdp;
+    if (!sdpText || payload.format !== "SDP" && !payload.sdp)
+      return;
+    if (this.sdpHandled)
+      return;
+    if (!this.turn) {
+      this.emit("error", new Error(`RTC ${this.opts.stationSn} offered before granting a relay`));
+      return;
+    }
+    this.sdpHandled = true;
+    let offer;
+    try {
+      offer = scallJsonToSdp(JSON.parse(sdpText));
+    } catch {
+      offer = sdpText;
+    }
+    const answer = await this.peer.handleRemoteOffer(offer);
+    this.signaling.sendInfoSdp(JSON.stringify(sdpToScallJson(answer)));
+    this.logger.debug(`[rtc] ${this.opts.stationSn} answered the hub's offer`);
+  }
+};
+
+// 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 RtcCommandRouter = class {
+  deps;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async dispatchCommand(route, cmd) {
+    if (cmd.kind !== "set-payload" && cmd.kind !== "set-json") {
+      throw new Error(`rtc: ${cmd.kind} is not routable over the T9000 control channel (only set-payload or set-json)`);
+    }
+    const identity = this.deps.identity();
+    if (!identity)
+      throw new Error(`rtc: not logged in, cannot drive ${route.stationSn}`);
+    const { stationSn } = route;
+    const adminUserId = route.adminUserId || identity.userId;
+    const channel = route.attached ? cmd.channel : PORTAL_STATION_CHANNEL;
+    const st = await this.stationSession(stationSn, adminUserId, identity);
+    const outerCmd = cmd.kind === "set-json" ? PORTAL_CMD_CONTROL_PAYLOAD : PORTAL_CMD_SET_PAYLOAD;
+    const innerCmd = cmd.kind === "set-json" ? cmd.param : cmd.cmd;
+    const payload = cmd.kind === "set-json" ? { account_id: adminUserId, cmd: cmd.param, commandType: cmd.param, data: cmd.data } : { account_id: adminUserId, cmd: cmd.cmd, mValue3: cmd.mValue3 ?? 0, payload: cmd.payload };
+    const segment = st.seg.next();
+    const packet = buildPortalPacket({ commandId: outerCmd, channel, segment, payload });
+    const run = st.queue.then(() => this.sendAwaitAck(stationSn, st, packet, outerCmd, innerCmd, channel, segment));
+    st.queue = run.catch(() => void 0);
+    return run;
+  }
+  /** Tear down every station session (logout / shutdown). */
+  close() {
+    for (const [sn, st] of this.sessions)
+      this.drop(sn, st);
+  }
+  /**
+   * 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
+   * not establish physical actuation. The command is sent once, bounded by {@link ACK_TIMEOUT_MS}.
+   */
+  sendAwaitAck(sn, st, packet, outerCmd, innerCmd, channel, segment) {
+    return new Promise((resolve, reject) => {
+      const onData = (frame, linkType) => {
+        const p = parsePortalPacket(frame, linkType);
+        if (!p || p.segment !== segment)
+          return;
+        const acknowledgement = linkType === PortalLinkType.COMMAND && p.commandId === outerCmd && !!p.isResponse;
+        const d = p.data;
+        const notification = outerCmd === PORTAL_CMD_CONTROL_PAYLOAD && linkType === PortalLinkType.NOTIFY && p.commandId === PORTAL_CMD_NOTIFY_PAYLOAD && p.isResponse === 0 && p.channel === channel && p.cmd === innerCmd && typeof d?.payload === "object" && d.payload !== null;
+        if (!acknowledgement && !notification)
+          return;
+        cleanup();
+        if (acknowledgement && p.errCode !== 0) {
+          reject(new Error(`rtc: ${sn} rejected cmd ${innerCmd} (err ${p.errCode})`));
+        } else {
+          this.deps.logger?.debug?.(`[rtc] ${sn} cmd ${innerCmd} acked`);
+          resolve();
+        }
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error(`rtc: ${sn} session closed while waiting for cmd ${innerCmd} ACK`));
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`rtc: ${sn} cmd ${innerCmd} ACK timed out after ${ACK_TIMEOUT_MS}ms`));
+      }, ACK_TIMEOUT_MS);
+      const cleanup = () => {
+        clearTimeout(timer);
+        st.session.off("commandData", onData);
+        st.session.off("close", onClose);
+        this.touch(sn, st);
+      };
+      st.session.on("commandData", onData);
+      st.session.on("close", onClose);
+      if (!st.session.sendCommand(packet)) {
+        cleanup();
+        reject(new Error(`rtc: ${sn} command channel not open, cmd ${innerCmd} not sent`));
+      }
+    });
+  }
+  async stationSession(sn, adminUserId, identity) {
+    const existing = this.sessions.get(sn);
+    if (existing) {
+      await existing.ready;
+      if (existing.session.isConnected) {
+        this.touch(sn, existing);
+        return existing;
+      }
+      this.drop(sn, existing);
+    }
+    const session = (this.deps.createSession ?? ((o) => new RtcSession(o)))({
+      authToken: identity.authToken,
+      gtoken: identity.gtoken,
+      stationSn: sn,
+      adminUserId,
+      shard: this.deps.shard(),
+      country: this.deps.country ?? "US",
+      logger: this.deps.logger,
+      peer: { logger: this.deps.logger }
+    });
+    const ready = this.bringUp(sn, session);
+    const st = { session, seg: new SegmentCounter(), ready, queue: Promise.resolve() };
+    session.on("error", (e) => this.deps.onError?.(e));
+    session.on("close", () => {
+      if (this.sessions.get(sn) === st)
+        this.sessions.delete(sn);
+    });
+    this.sessions.set(sn, st);
+    try {
+      await ready;
+    } catch (e) {
+      this.drop(sn, st);
+      throw e;
+    }
+    this.touch(sn, st);
+    return st;
+  }
+  /**
+   * One bounded bring-up: the session is up when its command channel opens, and it fails, with the
+   * session closed and every listener gone, when `connect()` throws, the session closes first, or
+   * {@link CONNECT_TIMEOUT_MS} passes. A single promise, so an early failure cannot leave a second one
+   * rejecting unheard.
+   */
+  bringUp(sn, session) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (err) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        session.off("connected", onConnected);
+        session.off("close", onClose);
+        if (err) {
+          try {
+            session.close();
+          } catch {
+          }
+          reject(err);
+        } else {
+          this.deps.logger?.info?.(`[rtc] ${sn} command channel up`);
+          resolve();
+        }
+      };
+      const onConnected = () => finish();
+      const onClose = () => finish(new Error(`rtc: ${sn} session closed before the command channel opened`));
+      const timer = setTimeout(() => finish(new Error(`rtc: ${sn} did not come up within ${CONNECT_TIMEOUT_MS2}ms`)), CONNECT_TIMEOUT_MS2);
+      session.once("connected", onConnected);
+      session.once("close", onClose);
+      Promise.resolve().then(() => session.connect()).catch((e) => finish(e instanceof Error ? e : new Error(String(e))));
+    });
+  }
+  touch(sn, st) {
+    if (st.idle)
+      clearTimeout(st.idle);
+    st.idle = setTimeout(() => this.drop(sn, st), IDLE_CLOSE_MS);
+    st.idle.unref?.();
+  }
+  drop(sn, st) {
+    if (st.idle)
+      clearTimeout(st.idle);
+    if (this.sessions.get(sn) === st)
+      this.sessions.delete(sn);
+    try {
+      st.session.close();
+    } catch {
+    }
+  }
+};
+
 // dist/transport/mqtt/command-router.js
 import { randomBytes as randomBytes3 } from "node:crypto";
 
@@ -22660,10 +23961,10 @@ function dpColorFields(spec) {
 }
 
 // dist/transport/mqtt/clean-codec.js
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 function buildCleanDpEnvelope(accountId, deviceSn, dp, value, opts) {
   const payload = JSON.stringify({
-    t: opts?.uuid ?? randomUUID2(),
+    t: opts?.uuid ?? randomUUID3(),
     protocol: 2,
     account_id: accountId,
     device_sn: deviceSn,
@@ -23350,7 +24651,7 @@ function deriveTuyaAccount(eufyUserId, phoneCode) {
 }
 
 // dist/transport/tuya/sign.js
-import { createHash as createHash5, createHmac as createHmac3 } from "node:crypto";
+import { createHash as createHash5, createHmac as createHmac4 } from "node:crypto";
 var SIGN_ALLOWLIST = /* @__PURE__ */ new Set([
   "a",
   "v",
@@ -23393,7 +24694,7 @@ var HmacSigner = class {
     this.key = key ?? process.env.TUYA_SIGN_KEY ?? TUYA_SIGN_K;
   }
   sign(preimage) {
-    return createHmac3("sha256", this.key).update(preimage, "utf-8").digest("hex");
+    return createHmac4("sha256", this.key).update(preimage, "utf-8").digest("hex");
   }
 };
 var TUYA_CHKEY = "7cbfe6d8";
@@ -23402,7 +24703,7 @@ var TUYA_CHKEY = "7cbfe6d8";
 import { randomBytes as randomBytes4, createHash as createHash6, createPublicKey, publicEncrypt, constants as constants2 } from "node:crypto";
 
 // dist/transport/tuya/request.js
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 var TUYA_API_ENDPOINT = "https://a1.tuyaeu.com/api.json";
 var TUYA_APP_KEY = "w8x4ppqkdxvqnd73ahj9";
 var TUYA_APP_SECRET = "pt585qhmt75hwcynchnps9dnxh9suhwd";
@@ -23434,7 +24735,7 @@ function buildApiParams(action, opts) {
     a: action.a,
     v: action.v,
     time: String(opts.time ?? Math.floor(Date.now() / 1e3)),
-    requestId: opts.requestId ?? randomUUID3(),
+    requestId: opts.requestId ?? randomUUID4(),
     sid: opts.session.sid,
     deviceId: opts.session.deviceId,
     chKey: opts.session.chKey,
@@ -23971,7 +25272,7 @@ async function resolveLightEffect(mega, lightId) {
 }
 
 // dist/transport/push/push-client.js
-import { EventEmitter as EventEmitter8 } from "node:events";
+import { EventEmitter as EventEmitter11 } from "node:events";
 import tls2 from "node:tls";
 
 // dist/transport/push/proto.js
@@ -24226,7 +25527,7 @@ var MessageTag;
 })(MessageTag || (MessageTag = {}));
 
 // dist/transport/push/parser.js
-import { EventEmitter as EventEmitter7 } from "node:events";
+import { EventEmitter as EventEmitter10 } from "node:events";
 var State;
 (function(State2) {
   State2[State2["VERSION_TAG_AND_SIZE"] = 0] = "VERSION_TAG_AND_SIZE";
@@ -24244,7 +25545,7 @@ var TAG_TO_TYPE = {
   [MessageTag.DataMessageStanza]: "mcs_proto.DataMessageStanza",
   [MessageTag.StreamErrorStanza]: "mcs_proto.StreamErrorStanza"
 };
-var McsParser = class extends EventEmitter7 {
+var McsParser = class extends EventEmitter10 {
   data = Buffer.alloc(0);
   state = State.VERSION_TAG_AND_SIZE;
   messageTag = 0;
@@ -24422,7 +25723,7 @@ function normalizePushEvent(raw) {
     raw
   };
 }
-var PushClient = class _PushClient extends EventEmitter8 {
+var PushClient = class _PushClient extends EventEmitter11 {
   creds;
   logger;
   /** Consecutive MCS login rejections tolerated (self-healing propagation) before surfacing an error. */
@@ -25575,7 +26876,7 @@ function readinessSnapshot(readiness, state = readiness.state) {
     wiredP2p: Object.freeze({ ...readiness.wiredP2p })
   });
 }
-var EufyMega = class extends EventEmitter9 {
+var EufyMega = class extends EventEmitter12 {
   opts;
   mega;
   /**
@@ -25635,6 +26936,8 @@ var EufyMega = class extends EventEmitter9 {
   prewarmTiers;
   /** Transport-side owner of the P2P sessions + all wire senders. */
   p2p;
+  /** Transport-side owner of the T9000 station sessions (sibling of {@link p2p}). */
+  rtc;
   /** Transport-side owner of the secure-MQTT ff09 lock/garage command path (sibling of {@link p2p}). */
   mqtt;
   /** Transport-side owner of the legacy Tuya REST command path for non-AIoT vacuums (G-series). */
@@ -25695,6 +26998,13 @@ var EufyMega = class extends EventEmitter9 {
       onLevel2Ready: (sn, cipherId) => this.emit("p2pLevel2Ready", { stationSn: sn, cipherId }),
       onFrame: (stationSn, f) => this.onP2PFrame(stationSn, f)
     });
+    this.rtc = new RtcCommandRouter({
+      identity: () => this.mega.rtcIdentity(),
+      shard: () => this.mega.rtcShard,
+      country: opts.countryCode,
+      logger: opts.logger,
+      onError: (e) => this.reportError(e)
+    });
     this.mqtt = new MqttCommandRouter({
       mega: this.mega,
       logger: opts.logger,
@@ -25960,13 +27270,22 @@ var EufyMega = class extends EventEmitter9 {
    *
    * The evidence set is widened, never replaced: the ids come back through the cloud record, and a
    * record that omits a realtime-only id would otherwise un-know it and re-trigger on the next report.
+   *
+   * The device is re-resolved against the fresh record before binding. A property gated on a
+   * realtime-only param enters the schema only once that param is evidence, and the value that made it
+   * evidence was stored before the property existed, so the record's realtime params are applied again
+   * to land it under the property's name.
    */
   async rebindReads(sn) {
     const dev = this.liveDevices.get(sn)?.deref();
     if (!dev)
       return;
     try {
-      const ctx = await this.commandContext(sn);
+      const rec = await this.registry.record(sn);
+      dev.reresolve(rec);
+      if (rec.dpParams)
+        this.applyAndAnnounce(dev, rec.dpParams);
+      const ctx = await this.commandContext(sn, rec);
       dev.bindActions(ctx, this.commandSinkFor(sn), this.mediaProviderFor(sn), this.ff09SettingsReaderFor(sn, ctx), rawDpCodec);
       this.boundParamIds.set(sn, /* @__PURE__ */ new Set([...this.boundParamIds.get(sn) ?? [], ...ctx.paramIds]));
       this.emit("deviceState", this.deviceState(sn));
@@ -26026,6 +27345,8 @@ var EufyMega = class extends EventEmitter9 {
    * only "differs from what was read before", which state already on hand can satisfy spuriously — and the
    * caller that has no expectation is the push path, where the signal itself is the news that a re-read is owed.
    *
+   * Only a write's observation throws at the deadline; a push with nothing moved answers `false`.
+   *
    * The cloud half is asked for through {@link DeviceRegistry.refreshedList}, never by fetching the account
    * list outright. The fetch is account-wide — one house list plus one device list per house — so a param that
    * never converges would otherwise spend a whole burst of those every iteration of this loop, and concurrent
@@ -26076,6 +27397,8 @@ var EufyMega = class extends EventEmitter9 {
         if (refresh.expected !== void 0 && settled())
           return true;
       }
+      if (refresh.expected === void 0)
+        return false;
       throw new StateConvergenceError({
         sn,
         property: refresh.property,
@@ -26428,8 +27751,9 @@ var EufyMega = class extends EventEmitter9 {
    * The `eufy_life` DP writes (smart lights) are secure-MQTT-only. `aiot-dp` routes to either the
    * Anker AIoT MQTT stack or the legacy Tuya REST router depending on the device's category
    * (`eufy_home_tuya` → Tuya, everything else → MQTT). The capability layer emits a single `aiot-dp`
-   * kind and stays transport-agnostic; only the facade sees both sides and decides here. Everything
-   * else is P2P.
+   * kind and stays transport-agnostic; only the facade sees both sides and decides here. A T9000
+   * station and the devices attached to it go over RTC, with an attached device's command refused
+   * unless its channel resolves back to it on the station. Everything else is P2P.
    */
   routeCommand(sn, cmd) {
     if (cmd.kind === "ff09-actuate" || cmd.kind === "ff09-autolock" || cmd.kind === "ff09-setting-toggle") {
@@ -26449,6 +27773,20 @@ var EufyMega = class extends EventEmitter9 {
         return this.tuya.dispatchCommand(sn, cmd);
       return this.mqtt.dispatchCommand(sn, cmd);
     }
+    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;
+    if (target && station && isStation9000({ deviceType, model: station.model })) {
+      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;
+      return this.rtc.dispatchCommand({ stationSn, adminUserId, attached }, cmd);
+    }
     return this.p2p.dispatchCommand(sn, cmd);
   }
   /**
@@ -27287,16 +28625,20 @@ var EufyMega = class extends EventEmitter9 {
     await this.commandSinkFor(sn).dispatch(cmd);
   }
   /**
-   * Restart a HomeBase.
+   * Restart a station: a HomeBase, or a camera-family device that is its own station.
    *
-   * **HomeBases only** — restart is a hub operation, so a non-HomeBase serial (a camera, an NVR)
-   * throws rather than doing nothing. The hub drops its connection and returns after a minute or two,
-   * so everything behind it is briefly offline. Verified on real hardware.
+   * The restart is `RESTART_HUB` on the station's broadcast channel, so it reaches whatever owns the
+   * P2P session. A standalone camera or doorbell owns its own session and is the station it restarts.
+   * A camera attached to a HomeBase is not — the same frame would restart its HomeBase — so its serial
+   * throws, as does any non-camera serial, rather than doing nothing. The device drops its connection
+   * and returns after a minute or two; a HomeBase takes everything behind it offline meanwhile.
+   * Verified on real hardware against a HomeBase and a standalone indoor camera.
    */
   async reboot(sn) {
     const ctx = await this.commandContext(sn);
-    if (!isHomeBase({ deviceType: ctx.deviceType, model: ctx.model })) {
-      throw new Error(`reboot: ${sn} is not a HomeBase (deviceType ${ctx.deviceType ?? "?"}, model ${ctx.model ?? "?"}) \u2014 restart is a hub-only operation`);
+    const standaloneCamera = ctx.codec === "camera" && this.p2p.stationKeyOf(sn) === sn;
+    if (!isHomeBase({ deviceType: ctx.deviceType, model: ctx.model }) && !standaloneCamera) {
+      throw new Error(`reboot: ${sn} is neither a HomeBase nor a standalone camera (deviceType ${ctx.deviceType ?? "?"}, model ${ctx.model ?? "?"}) \u2014 restart addresses the station that owns the P2P session`);
     }
     await this.p2p.rebootStation(sn);
   }
@@ -27328,8 +28670,9 @@ var EufyMega = class extends EventEmitter9 {
       return EMPTY_DP_CATALOG;
     }
   }
-  async commandContext(sn) {
-    const rec = await this.registry.record(sn);
+  /** The {@link CommandContext} for a device, built from `known` when that record is already in hand. */
+  async commandContext(sn, known) {
+    const rec = known ?? await this.registry.record(sn);
     const dev = this.registry.require(sn);
     const raw = dev.raw ?? {};
     const rawChannel = raw.device_channel;
@@ -27542,6 +28885,7 @@ var EufyMega = class extends EventEmitter9 {
     this.pollTimer.cancel();
     this.lastStateAnnounced.clear();
     await this.closeMqttTransports();
+    this.rtc.close();
     await this.p2p.closeAll();
     this.pushClient?.close();
     this.pushClient = void 0;
@@ -28046,7 +29390,7 @@ var SolixClient = class _SolixClient {
 };
 
 // dist/transport/mqtt/solix-mqtt.js
-import { EventEmitter as EventEmitter10 } from "node:events";
+import { EventEmitter as EventEmitter13 } from "node:events";
 var SOLIX_METER_FIELD_NAMES = {
   168: "meterPowerL1",
   // Anker Modbus: primary_phase_1_active_power
@@ -28224,7 +29568,7 @@ function addSolarbankScalars(frame, out) {
     out.gridExportLimit = df.readUInt16LE(5);
   }
 }
-var SolixMqtt = class extends EventEmitter10 {
+var SolixMqtt = class extends EventEmitter13 {
   transport;
   appName;
   userId;