@mega-yfue/eufy-sdk 0.5.0-beta.2 → 0.5.0-beta.20

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";
@@ -1974,6 +1996,17 @@ ${this.auth_?.authToken ?? ""}`;
       device_sns: [deviceSn]
     });
   }
+  /**
+   * Fetch the account's devices as the `devicerelation` service lists them, `{attribute: 7, house_id: ""}`.
+   *
+   * Each entry is `{device: {device_sn, dps, …}}`, and `dps` is the cloud's last-known value of every
+   * data point that device has reported, keyed by DP number. Answered for an account a device is shared
+   * with as well as for its owner. Sent with `category: eufy_home`, without which the service answers
+   * `10000`.
+   */
+  getDeviceRelationList() {
+    return this.post("devicerelation", "/app/devicerelation/get_device_list", { attribute: 7, house_id: "" }, { category: "eufy_home" });
+  }
   /**
    * Fetch one page of a device's **cleaning history** from the mega `clean` service.
    *
@@ -2422,6 +2455,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 +5094,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";
 
@@ -5205,6 +5240,8 @@ var AUDIO = {
 
 // dist/model/capabilities/camera.js
 var CAMERA_CMD = {
+  /** Camera-reported Wi-Fi signal (app `CMD_GET_WIFI_RSSI`). */
+  WIFI_RSSI: 1142,
   /** Camera on/off. Read and write polarity depend on the family and topology. */
   CAMERA_ENABLE: 1035,
   /** Wrapped T8410 power switch on HomeBase 3. */
@@ -5484,6 +5521,14 @@ function refuseWhenDisabled(ctx, read) {
     throw new CameraDisabledError(ctx.name ?? ctx.serial);
 }
 var CAMERA_MEMBERS = {
+  /** Reads the latest cached report and exposes no setter. */
+  wifiRssi: {
+    param: CAMERA_CMD.WIFI_RSSI,
+    type: "number",
+    kind: "scalar",
+    provenance: "apk",
+    description: "Camera-reported Wi-Fi signal; physical units and a quality scale are unspecified."
+  },
   /**
    * The default READ is the *disable*-bit convention (1035 "0" ⇒ ON, 2001 direct); the WRITE polarity is
    * family-dependent — see `powerValue` / `isEnableBitPolarity`. Battery/solo cams report the state under
@@ -5640,16 +5685,14 @@ var CAMERA_MEMBERS = {
    * Live-view quality, the pair to {@link CAMERA_MEMBERS.recordingQuality} and a different setting on a
    * different wire: changing one leaves the other's parameter untouched.
    *
-   * The READ is 1020, which reports the resolved tier as a plain integer. 1020 is also the name the
-   * param dictionary already gives that id, and `Device` keys state by NAME — a member claiming 2730
-   * under this name would collide with it on a device reporting both.
+   * The READ is 1020, which reports the resolved tier as a plain integer, while the WRITE rides 2730's
+   * `1350` payload. They are two ids for one setting because 2730 carries a per-mode config and 1020
+   * carries the tier in force; the tier is what this property means. 1020 is also the name the param
+   * dictionary already gives that id, and `Device` keys state by NAME — a member claiming 2730 under
+   * this name would collide with it on a device reporting both.
    *
-   * `unverified: true` with no `write`: the app's 2730 frame is captured byte-exact, but replaying it
-   * from this SDK produced no observable change on a standalone T8171, where the recording sibling's
-   * 2731 write on the same envelope and the same session does land. The one difference the capture
-   * shows is that the app's frame carries no `mChannel`/`mValue3`, which this envelope always emits.
-   * Until a send is confirmed, the setter is absent — a control that silently does nothing is worse
-   * than none — and the read ships ahead of it, which verification per direction allows.
+   * `transaction` is part of the frame that was captured, so it is sent. The recording sibling's own
+   * confirmed frame carries no such field; neither is inferred from the other.
    */
   streamingQuality: {
     param: 1020,
@@ -5657,8 +5700,13 @@ var CAMERA_MEMBERS = {
     kind: "enum",
     enumValues: STREAMING_QUALITY_TIERS,
     provenance: "verified",
-    unverified: true,
-    description: "Live-view quality as a tier, 0 = Auto (1020). Distinct from recordingQuality, which is what gets stored. All four tiers confirmed on a T8170 and a T8171. The WRITE (2730) is unconfirmed from this SDK, so no setter is offered rather than one that reports success without acting \u2014 see CAMERA_CMD.STREAMING_QUALITY_SET."
+    args: [{ name: "quality", kind: "enum", description: "A tier, or the name it maps to. 0 is Auto." }],
+    ...accepts(),
+    description: "Live-view quality as a tier, 0 = Auto (1020; the write rides 2730 APP_CMD_MULTI_CAM_SET_VIDEO_QUALITY). Distinct from recordingQuality, which is what gets stored. All four tiers wire-verified live on a T8170 and read back on 1020. Sent from this SDK to a standalone T8170 and T8171, tier 1 holds the live stream at 1280x720 and tier 0 restores the camera's own resolution ladder \u2014 see CAMERA_CMD.STREAMING_QUALITY_SET. A value outside the tier set is REJECTED, not clamped: every tier in range is a real quality, so a bad one would silently pick another.",
+    write: (v, ctx) => {
+      const q = resolveStreamingQualityTier(v);
+      return q == null ? void 0 : setPayload(CAMERA_CMD.STREAMING_QUALITY_SET, { channel: 0, mode: 0, primary_view: 0, quality: q, transaction: String(Date.now()) }, ctx, 0, void 0, "auto");
+    }
   },
   /**
    * `type` is how the value is STORED, and 2731 stores the whole config — the ACTIVE tier is lifted out
@@ -6188,6 +6236,9 @@ var LIGHT_MEMBERS = {
    * This is the switch a user changes and expects to STAY changed. {@link isOn} is a different fact:
    * the lamp being lit right now, driven by whichever
    * client is streaming — the vendor app lights it for a live view and drops it on quitting.
+   *
+   * The T8423 write takes the session-chosen level; level-1 int+string was verified live on a standalone
+   * unit.
    */
   spotlightEnabled: {
     param: LIGHT_CMD.SPOTLIGHT_ENABLE,
@@ -6195,7 +6246,7 @@ var LIGHT_MEMBERS = {
     kind: "boolean",
     provenance: "verified",
     description: "The spotlight master switch, distinct from the on/off above \u2014 whether the spotlight may light at all. Read verified live on a T8170 (param 1403, direct polarity: 1 = enabled).",
-    write: (v, ctx) => directBinary(LIGHT_CMD.SPOTLIGHT_ENABLE, asBool(v) ? 1 : 0, ctx),
+    write: (v, ctx) => setScalar(LIGHT_CMD.SPOTLIGHT_ENABLE, asBool(v) ? 1 : 0, ctx, ctx.deviceType === DeviceType.FLOODLIGHT_CAMERA_8423 ? "auto" : "direct-binary"),
     writeAs: "setEnabled"
   }
 };
@@ -8312,8 +8363,6 @@ var MODE_CTRL_FIELD = {
   SEQ: 2
 };
 var ModeCtrlMethod = {
-  /** Live-verified on a T2351. Zero, so it is omitted from the wire per the proto3 default rule. */
-  START_AUTO_CLEAN: 0,
   /** Live-verified on a T2351. */
   START_GOHOME: 6,
   /** Live-verified on a T2351. */
@@ -8337,6 +8386,8 @@ var ModeCtrlMethod = {
   START_GLOBAL_CRUISE: 20
 };
 var ModeCtrlParamMethod = {
+  /** `START_AUTO_CLEAN` with an `AutoClean` payload — clean the whole floor. */
+  AUTO: { method: 0, param: 3 },
   /** `START_SELECT_ROOMS_CLEAN` — clean the named rooms of a named map. */
   SELECT_ROOMS: { method: 1, param: 4 },
   /** `START_SELECT_ZONES_CLEAN` — clean the given rectangles of a named map. */
@@ -8373,6 +8424,7 @@ var SELECT_ZONES_FIELD = {
   POINT_Y: 2
 };
 var SCENE_CLEAN_ID = 1;
+var AUTO_CLEAN_TIMES = 1;
 function encodeModeCtrlParam(method2, paramField, build) {
   return rawDp((w) => {
     if (method2 !== 0)
@@ -8419,14 +8471,17 @@ function encodeSceneClean(sceneId) {
   const { method: method2, param } = ModeCtrlParamMethod.SCENE;
   return encodeModeCtrlParam(method2, param, (p) => p.int(SCENE_CLEAN_ID, sceneId));
 }
+function encodeAutoClean() {
+  const { method: method2, param } = ModeCtrlParamMethod.AUTO;
+  return encodeModeCtrlParam(method2, param, (p) => p.int(AUTO_CLEAN_TIMES, 1));
+}
 var modeCtrlSeq = 111;
 function nextModeCtrlSeq() {
   return ++modeCtrlSeq;
 }
 function encodeModeCtrl(method2, seq) {
   return rawDp((w) => {
-    if (method2 !== 0)
-      w.int(MODE_CTRL_FIELD.METHOD, method2);
+    w.int(MODE_CTRL_FIELD.METHOD, method2);
     w.int(MODE_CTRL_FIELD.SEQ, seq);
   });
 }
@@ -10268,8 +10323,8 @@ var VACUUM_CLEAN_MEMBERS = {
     provenance: "mega",
     description: "Stop smart-follow mode (ModeCtrlRequest method 18 over DP 152). Method number not captured \u2014 unverified."
   },
-  /** Start an auto-clean run via ModeCtrlRequest method 0 (DP 152). AIoT only — Tuya write unverified. */
-  startCleaning: method(({ sink }) => () => sink.dispatch(aiotDp(VACUUM_DP.MODE_CTRL, encodeModeCtrl(ModeCtrlMethod.START_AUTO_CLEAN, nextModeCtrlSeq()))), "Start an auto-clean run (ModeCtrlRequest method 0 over DP 152).", isAiotVacuum),
+  /** Start an auto-clean run via ModeCtrlRequest method 0 with one `AutoClean` pass (DP 152). AIoT only — Tuya write unverified. */
+  startCleaning: method(({ sink }) => () => sink.dispatch(aiotDp(VACUUM_DP.MODE_CTRL, encodeAutoClean())), "Start an auto-clean run (ModeCtrlRequest method 0, AutoClean clean_times 1, over DP 152).", isAiotVacuum),
   /** Return to the dock via ModeCtrlRequest method 6 (DP 152). AIoT only — Tuya write unverified. */
   returnToDock: method(({ sink }) => () => sink.dispatch(aiotDp(VACUUM_DP.MODE_CTRL, encodeModeCtrl(ModeCtrlMethod.START_GOHOME, nextModeCtrlSeq()))), "Return to the dock (ModeCtrlRequest method 6 over DP 152).", isAiotVacuum),
   /** Pause the current cleaning task via ModeCtrlRequest method 13 (DP 152). AIoT only — Tuya write unverified. */
@@ -11018,6 +11073,8 @@ var MODEL_REGISTRY = {
   T8210: { codec: "camera", caps: ["doorbell", "battery"], name: "Video Doorbell" },
   // Confirmed against a real owned unit (named "Doorbell"): Video Doorbell Dual.
   T8214: { codec: "camera", caps: ["doorbell", "battery"], name: "Video Doorbell Dual" },
+  // Battery Video Doorbell Dual, vendor deviceType 91 (BATTERY_DOORBELL_PLUS), reported by two users.
+  T8213: { codec: "camera", caps: ["doorbell", "battery"], name: "Video Doorbell Dual" },
   // Confirmed against a real owned unit: the mains-powered Wired Doorbell 2K. No `battery` row
   // member on purpose — this model is wired, so the codec baseline plus inference is the whole
   // truth for power. Without this row it classified as a plain camera, so the doorbell capability
@@ -11179,8 +11236,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 +15758,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 +15775,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 +16308,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:
@@ -16468,7 +16543,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       camera_type: 0,
       entrytype: 0,
       key: this.rsaModulus(),
-      streamtype: 1,
+      streamtype: 2,
       ...payload
     } : payload;
     const value = JSON.stringify({
@@ -16809,11 +16884,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 +16956,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 +17597,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 +17618,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 [];
@@ -17878,6 +17960,7 @@ var AUDIO_HEADER_LEN = 16;
 var AUDIO_TYPE_OFFSET = 5;
 var SC4 = Buffer.from([0, 0, 0, 1]);
 var SC3 = Buffer.from([0, 0, 1]);
+var AAC_ELD_AUDIO_SPECIFIC_CONFIG = Buffer.from("f8f03000", "hex");
 var AUDIO_CODECS = { 0: "aac-lc", 2: "g711a", 7: "aac-eld" };
 var MAX_TRACED_DECODE_FAILURES = 3;
 var DEFAULT_KEEPALIVE_MS = 3e3;
@@ -17891,6 +17974,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 +18022,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 +18120,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 +18157,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 });
@@ -18092,7 +18189,7 @@ var LiveStream = class extends EventEmitter3 {
           if (!codec) {
             this.logger.debug(`[live] dropping audio frame: unknown codec id ${codecId ?? "missing"}`);
           } else {
-            this.emit("audio", { codec, data: audio });
+            this.emit("audio", codec === "aac-eld" ? { codec, data: audio, config: AAC_ELD_AUDIO_SPECIFIC_CONFIG } : { codec, data: audio });
           }
         }
       }
@@ -18159,6 +18256,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);
@@ -19828,7 +19926,8 @@ var AdtsFrameReader = class {
 };
 
 // dist/transport/p2p/talkback.js
-var DEFAULT_HIGH_WATER_FRAMES = Math.ceil(2e3 / AAC_FRAME_MS);
+var HIGH_WATER_MS = 2e3;
+var TALKBACK_ELD_FRAME_MS = 32;
 var DEFAULT_IDLE_TIMEOUT_MS = 3e4;
 var Talkback = class extends EventEmitter5 {
   sink;
@@ -19836,7 +19935,8 @@ var Talkback = class extends EventEmitter5 {
   reader = new AdtsFrameReader();
   queue = [];
   logger;
-  highWater;
+  /** Playback duration of one queued frame, the pacer's step: 64 ms for `aac-lc`, 32 ms for `aac-eld`. */
+  frameMs = AAC_FRAME_MS;
   idleTimeoutMs;
   timer;
   started = false;
@@ -19862,9 +19962,14 @@ var Talkback = class extends EventEmitter5 {
     this.sink = sink;
     this.opts = opts;
     this.logger = opts.logger ?? noopLogger;
-    this.highWater = opts.highWaterFrames ?? DEFAULT_HIGH_WATER_FRAMES;
     this.idleTimeoutMs = opts.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
   }
+  /** Frames the pacing queue holds before a writable applies backpressure: {@link HIGH_WATER_MS} of this codec. */
+  get highWater() {
+    return this.opts.highWaterFrames ?? Math.ceil(HIGH_WATER_MS / this.frameMs);
+  }
+  /** The codec this talkback sends, set by {@link start}. */
+  codec = "aac-lc";
   /** Frames still queued for the wire. */
   get pending() {
     return this.queue.length;
@@ -19873,25 +19978,33 @@ var Talkback = class extends EventEmitter5 {
    * Open the device's talkback path and begin the pacing tick. Throws when the topology's control
    * frame could not be sent — for a HomeBase-attached camera that means the level-2 key was never
    * negotiated, which would otherwise leave a silent session that accepts audio nobody hears.
+   *
+   * `codec` is the codec the camera's speaker plays; it fixes the input this talkback accepts and the pacing step.
    */
-  start() {
+  start(codec) {
     if (this.started)
       return this;
+    if (codec === "aac-eld" && this.opts.encoder) {
+      throw new Error("talkback: this camera plays aac-eld; an AacEncoder produces aac-lc");
+    }
+    this.codec = codec;
+    this.frameMs = codec === "aac-eld" ? TALKBACK_ELD_FRAME_MS : AAC_FRAME_MS;
     if (!this.sink.startTalkback(this.opts.channel, this.opts.homeBaseAttached)) {
       throw new Error(`talkback: could not open the audio path on channel ${this.opts.channel}`);
     }
     this.started = true;
     const now2 = Date.now();
-    this.nextDueAt = now2 + AAC_FRAME_MS;
+    this.nextDueAt = now2 + this.frameMs;
     this.lastWriteAt = now2;
-    this.timer = setInterval(() => this.tick(), AAC_FRAME_MS);
+    this.timer = setInterval(() => this.tick(), this.frameMs);
     this.timer.unref?.();
     this.sink.on?.("audioGap", this.onAudioGap);
     return this;
   }
   /**
-   * Queue audio. Bytes are ADTS AAC, or PCM when an encoder was supplied; either way the input is
-   * treated as a stream, so a chunk carrying part of a frame is held until the rest arrives.
+   * Queue audio in the codec this talkback sends. For `aac-lc` the bytes are ADTS, or PCM when an encoder was
+   * supplied, read as a stream, so a chunk carrying part of a frame is held until the rest arrives. For `aac-eld`
+   * each call is one whole access unit; a unit over the device's length limit is dropped with an `error`.
    *
    * Audio written after {@link end} is dropped with an `error` rather than queued: `finished` has
    * either already fired or is owed on the frames written before it, so a late chunk would either play
@@ -19905,6 +20018,15 @@ var Talkback = class extends EventEmitter5 {
       return;
     }
     this.lastWriteAt = Date.now();
+    if (this.codec === "aac-eld") {
+      if (chunk.length > MAX_AUDIO_FRAME_BYTES) {
+        this.fail(new Error(`talkback: frame of ${chunk.length} B exceeds the device's ${MAX_AUDIO_FRAME_BYTES} B limit`));
+        return;
+      }
+      if (chunk.length)
+        this.queue.push(chunk);
+      return;
+    }
     if (!this.opts.encoder) {
       this.enqueue(this.reader.push(chunk));
       return;
@@ -19973,14 +20095,14 @@ var Talkback = class extends EventEmitter5 {
       return;
     const now2 = Date.now();
     if (!this.queue.length) {
-      this.nextDueAt = now2 + AAC_FRAME_MS;
+      this.nextDueAt = now2 + this.frameMs;
       this.idleCheck(now2);
       this.announceFinishIfDone();
       return;
     }
     while (this.queue.length && now2 >= this.nextDueAt) {
       const frame = this.queue.shift();
-      this.nextDueAt += AAC_FRAME_MS;
+      this.nextDueAt += this.frameMs;
       try {
         this.sink.sendAudioFrame(this.opts.channel, frame);
       } catch (e) {
@@ -20038,9 +20160,11 @@ var Talkback = class extends EventEmitter5 {
   /**
    * A Writable over {@link write} that withholds its callback while the queue is at the high-water
    * mark — which is what turns `pipe()` from a file into playback at speed rather than a memory spike.
+   * For `aac-eld` it is object-mode: each write is one access unit.
    */
   writable() {
     return new Writable({
+      objectMode: this.codec === "aac-eld",
       write: (chunk, _enc, cb) => {
         this.write(chunk);
         if (this.queue.length < this.highWater)
@@ -20109,7 +20233,7 @@ var CODEC_BOXES = {
   h264: { sample: "avc1", config: "avcC" },
   h265: { sample: "hvc1", config: "hvcC" }
 };
-var AAC_ELD_SAMPLES_PER_FRAME = 512;
+var AAC_ELD_SAMPLES_PER_FRAME = 480;
 var ADTS_FREQUENCY_INDEX_16K = 8;
 var ADTS_CHANNELS_MONO = 1;
 var Fmp4Muxer = class {
@@ -20127,6 +20251,8 @@ var Fmp4Muxer = class {
   lastVideoTimestampMs;
   audioRequested;
   audioCodec;
+  /** Decoder config of an AAC-ELD track, taken from its frames; absent for AAC-LC, whose `esds` config is fixed. */
+  audioConfig;
   audioDisabled = false;
   audioSamples = [];
   audioBaseDecodeTime = 0;
@@ -20193,7 +20319,10 @@ var Fmp4Muxer = class {
     }
     return void 0;
   }
-  /** Add one station-declared AAC access unit to the audio track. G.711 remains available via `live()`. */
+  /**
+   * Add one station-declared AAC access unit to the audio track: an ADTS frame for AAC-LC, a raw access unit
+   * described by its frame's config for AAC-ELD. G.711 remains available via `live()`.
+   */
   pushAudio(frame, timestampMs = now()) {
     if (!this.audioRequested || this.audioDisabled)
       return void 0;
@@ -20209,12 +20338,19 @@ var Fmp4Muxer = class {
     if (this.audioCodec && this.audioCodec !== frame.codec) {
       return this.disableAudio();
     }
-    const header = parseAdtsHeader(frame.data);
-    if (!header || header.frameLength > frame.data.length) {
-      throw new Error(`fMP4 muxer: ${frame.codec} frame is not a complete ADTS access unit`);
-    }
-    if (header.frequencyIndex !== ADTS_FREQUENCY_INDEX_16K || header.channels !== ADTS_CHANNELS_MONO) {
-      return this.disableAudio();
+    let sample;
+    if (frame.codec === "aac-eld") {
+      this.audioConfig = frame.config;
+      sample = frame.data;
+    } else {
+      const header = parseAdtsHeader(frame.data);
+      if (!header || header.frameLength > frame.data.length) {
+        throw new Error(`fMP4 muxer: ${frame.codec} frame is not a complete ADTS access unit`);
+      }
+      if (header.frequencyIndex !== ADTS_FREQUENCY_INDEX_16K || header.channels !== ADTS_CHANNELS_MONO) {
+        return this.disableAudio();
+      }
+      sample = frame.data.subarray(header.headerLength, header.frameLength);
     }
     this.audioCodec = frame.codec;
     this.firstAudioTimestampMs ??= timestampMs;
@@ -20226,7 +20362,7 @@ var Fmp4Muxer = class {
       this.audioSamples[this.audioSamples.length - 1].duration = measured;
     }
     this.audioSamples.push({
-      data: frame.data.subarray(header.headerLength, header.frameLength),
+      data: sample,
       duration: frame.codec === "aac-eld" ? AAC_ELD_SAMPLES_PER_FRAME : AAC_SAMPLES_PER_FRAME,
       keyframe: true
     });
@@ -20499,7 +20635,7 @@ var Fmp4Muxer = class {
     return box("mp4a", head, this.esds());
   }
   esds() {
-    const config = this.audioCodec === "aac-eld" ? Buffer.from([248, 240, 32]) : Buffer.from([20, 8]);
+    const config = this.audioConfig ?? Buffer.from([20, 8]);
     const specific = descriptor(5, config);
     const decoder = descriptor(4, Buffer.concat([Buffer.from([64, 21, 0, 0, 0]), u32(64e3), u32(32e3), specific]));
     const sl = descriptor(6, Buffer.from([2]));
@@ -20756,6 +20892,30 @@ var P2P_STATION_WAITS = {
   level2Settle: LEVEL2_SETTLE_MS
 };
 var RTSP_URL_READ_TIMEOUT_MS = 12e3;
+var TALKBACK_CODEC_WAIT_MS = 3e3;
+var ELD_TALKBACK_MODELS = /* @__PURE__ */ new Set(["T8410C"]);
+function speakerCodec(consumer, talk, timeoutMs) {
+  return new Promise((resolve) => {
+    let timer;
+    const settle = (codec) => {
+      clearTimeout(timer);
+      consumer.off("video", onVideo);
+      consumer.off("audio", onAudio);
+      consumer.off("stop", onStop);
+      talk.off("stop", onStop);
+      resolve(codec);
+    };
+    const onVideo = () => {
+      timer ??= setTimeout(() => settle("aac-lc"), timeoutMs);
+    };
+    const onAudio = (frame) => settle(frame.codec === "aac-eld" ? "aac-eld" : "aac-lc");
+    const onStop = () => settle("aac-lc");
+    consumer.on("video", onVideo);
+    consumer.on("audio", onAudio);
+    consumer.on("stop", onStop);
+    talk.once("stop", onStop);
+  });
+}
 var SHARED_LIVE_OPT_KEYS = [
   "eccPrivateKey",
   "keepAliveMs",
@@ -21174,14 +21334,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`.
@@ -21303,6 +21469,11 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * stream costs nothing extra and a talkback on an otherwise idle camera opens the session it needs
    * instead of playing into silence.
    *
+   * **On a model in {@link ELD_TALKBACK_MODELS}, the speaker plays the codec the camera sends.** So the first
+   * audio frame of the media session this talkback holds decides its codec ({@link speakerCodec}), within
+   * {@link TALKBACK_CODEC_WAIT_MS} of the session's first frame, and the claim is re-checked after that wait as
+   * after the warm-up. Every other model opens `aac-lc` at once.
+   *
    * The level-2 key is waited for softly: only the HomeBase-attached path requires it, and
    * {@link Talkback.start} reports that failure precisely, so a hard wait here would reject an
    * own-session camera that legitimately never negotiates one.
@@ -21372,7 +21543,11 @@ var P2PCommandRouter = class _P2PCommandRouter {
       consumer.on("stop", () => {
         void talk.stop().catch((e) => logger.warn?.(`talkback: stop for ${sn} failed: ${String(e)}`));
       });
-      return talk.start();
+      const codec = ELD_TALKBACK_MODELS.has(this.recordFor(sn)?.model ?? "") ? await speakerCodec(consumer, talk, TALKBACK_CODEC_WAIT_MS) : "aac-lc";
+      if (this.talkbacks.get(key) !== talk) {
+        throw new Error(`talkback: ${sn} was closed while its speaker codec was being read`);
+      }
+      return talk.start(codec);
     } catch (e) {
       if (this.talkbacks.get(key) === talk)
         this.talkbacks.delete(key);
@@ -22357,6 +22532,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 +24066,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 +24756,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 +24799,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 +24808,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 +24840,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 +25377,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 +25632,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 +25650,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 +25828,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. */
@@ -25012,7 +26418,14 @@ function deviceClassOf(codec, realtime) {
   const cls = CLASS_BY_CODEC[codec];
   return cls === "camera" && realtime !== "p2p" ? "other" : cls;
 }
+function recordName(raw, deviceClass) {
+  if (deviceClass === "vacuum") {
+    return raw.alias_name || raw.device_alias_name || raw.device_name || void 0;
+  }
+  return raw.device_name ?? raw.device_alias_name ?? raw.alias_name;
+}
 var LIST_REUSE_MS = 5e3;
+var CLOUD_DPS_MODELS = /* @__PURE__ */ new Set(["T2351"]);
 var DeviceRegistry = class {
   mega;
   onError;
@@ -25037,6 +26450,8 @@ var DeviceRegistry = class {
   overlayRefusalReported = false;
   /** Per-serial capability cache for {@link capabilitiesForDevice}; `null` = negative hit. */
   deviceCapsCache = /* @__PURE__ */ new Map();
+  /** Per-serial cloud data points of an AIoT robot, joined beneath the params in {@link record} — see {@link loadCloudDps}. */
+  cloudDps = /* @__PURE__ */ new Map();
   /** Per-serial realtime state, keyed by param id in the device's own namespace (see {@link DeviceRecord.dpParams}). */
   dpParams = /* @__PURE__ */ new Map();
   /** Callers blocked in {@link awaitRealtimeState}, released by the device's first report. */
@@ -25131,9 +26546,10 @@ var DeviceRegistry = class {
           category: raw.category,
           params
         }).codec;
+        const deviceClass = deviceClassOf(codec, c.realtime);
         seen.set(raw.device_sn, {
           sn: raw.device_sn,
-          name: raw.device_name ?? raw.device_alias_name ?? raw.alias_name,
+          name: recordName(raw, deviceClass),
           model: raw.device_model,
           stationSn: resolvedStationSn(raw, raw.device_sn),
           p2pDid: raw.p2p_did,
@@ -25141,11 +26557,12 @@ var DeviceRegistry = class {
           paramUpdatedAt,
           lastSeenMs: lastSeenMsOf(paramUpdatedAt),
           raw,
-          deviceClass: deviceClassOf(codec, c.realtime),
+          deviceClass,
           ...c
         });
       }
     }
+    await this.loadCloudDps(seen);
     this.lastRefreshPartial = partial;
     if (partial) {
       for (const prev of this.devices)
@@ -25236,9 +26653,46 @@ var DeviceRegistry = class {
     }
     return dev;
   }
+  /**
+   * Hold an AIoT robot's cloud data points: the cloud's last-known value of each one it has reported,
+   * from `getDeviceRelationList`'s per-device `dps`.
+   *
+   * The device list carries only some of a robot's data points, so a point the robot publishes on change
+   * alone (its scene list, its schedules, its consumables) has no value until it next reports. The
+   * relation list holds every one, for an account the robot is shared with as well as its owner.
+   *
+   * Kept apart from the device list's params rather than merged into them: those are what a poll diffs,
+   * and a diff retires the realtime report for that id, so a cloud value lagging the robot's last report
+   * would replace it. {@link record} joins this beneath both halves. A failure keeps what was held.
+   *
+   * Limited to {@link CLOUD_DPS_MODELS}, the models whose relation-list `dps` are checked to carry the
+   * DP numbers their realtime reports use.
+   */
+  async loadCloudDps(seen) {
+    const robots = [...seen.values()].filter((d) => CLOUD_DPS_MODELS.has(d.model ?? ""));
+    if (!robots.length)
+      return;
+    let res;
+    try {
+      res = await this.mega.getDeviceRelationList();
+    } catch (e) {
+      if (e instanceof SessionExpiredError)
+        throw e;
+      this.logger.debug(`[registry] device relation list unavailable: ${e?.message ?? e}`);
+      return;
+    }
+    const wanted = new Set(robots.map((d) => d.sn));
+    for (const entry of res.devices ?? []) {
+      const sn = entry?.device?.device_sn;
+      const dps = parseAiotDpReport({ payload: entry?.device?.dps });
+      if (sn && wanted.has(sn) && dps)
+        this.cloudDps.set(sn, dps);
+    }
+  }
   /**
    * Resolve a serial to a {@link DeviceRecord} with current params: starts from the device-list params, then
-   * overlays a fresh `get_device_param_list` when that call is available to this account.
+   * overlays a fresh `get_device_param_list` when that call is available to this account. An AIoT robot's
+   * cloud data points ({@link loadCloudDps}) sit beneath both, filling only ids neither carries.
    *
    * The overlay is **owner-gated** — a shared or member account is refused it for every device, permanently,
    * which {@link OWNER_ONLY_CODE} identifies — so when it is unavailable the device list is the source
@@ -25267,7 +26721,7 @@ var DeviceRegistry = class {
     let dev = this.devices.find((d) => d.sn === sn);
     if (!dev)
       throw new Error(`device ${sn} not found (have: ${this.devices.map((d) => d.sn).join(", ")})`);
-    const params = { ...dev.params ?? {} };
+    const params = { ...this.cloudDps.get(sn), ...dev.params ?? {} };
     const paramUpdatedAt = { ...dev.paramUpdatedAt ?? {} };
     if (!this.overlayRefused.has(sn)) {
       try {
@@ -25575,7 +27029,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 +27089,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 +27151,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 +27423,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 +27498,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 +27550,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 +27904,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 +27926,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 +28778,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 +28823,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 +29038,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 +29543,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 +29721,7 @@ function addSolarbankScalars(frame, out) {
     out.gridExportLimit = df.readUInt16LE(5);
   }
 }
-var SolixMqtt = class extends EventEmitter10 {
+var SolixMqtt = class extends EventEmitter13 {
   transport;
   appName;
   userId;