@mega-yfue/eufy-sdk 0.5.0-beta.5 → 0.5.0-beta.50

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 EventEmitter13 } from "node:events";
 
 // dist/transport/http/mega-client.js
 import { createHash as createHash3 } from "node:crypto";
@@ -196,6 +196,11 @@ var ConsoleLogger = class {
   }
 };
 
+// dist/transport/token-echo.js
+function withoutTokenEcho(text2) {
+  return text2.replace(/token\s*[=:]\s*"?[A-Za-z0-9._-]{8,}"?/gi, "token = <redacted>");
+}
+
 // dist/transport/http/media-download.js
 import { lookup } from "node:dns/promises";
 import { BlockList, isIP } from "node:net";
@@ -615,7 +620,8 @@ function scanEntropy(tail, subsampling, extraTables) {
 // dist/transport/http/decodeImageV2.js
 import { decode as jpegDecode } from "jpeg-js";
 var V2_PREFIX = "v2_eufysecurity:";
-var DC_CHROMA = Buffer.from([255, 196, 0, 31, 1]);
+var DRI_SEGMENT = Buffer.from([255, 221, 0, 4]);
+var SOS_HEADER = Buffer.from([255, 218, 0, 12, 3]);
 var ZIGZAG = [
   0,
   1,
@@ -816,6 +822,9 @@ var QUANT_CHROMA = [
 ];
 var DHT_DC_LUMA = Buffer.from("ffc4001f0000010501010101010100000000000000000102030405060708090a0b", "hex");
 var DHT_AC_LUMA = Buffer.from("ffc400b5100002010303020403050504040000017d01020300041105122131410613516107227114328191a1082342b1c11552d1f02433627282090a161718191a25262728292a3435363738393a434445464748494a535455565758595a636465666768696a737475767778797a838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae1e2e3e4e5e6e7e8e9eaf1f2f3f4f5f6f7f8f9fa", "hex");
+var DHT_DC_CHROMA = Buffer.from("ffc4001f0100030101010101010101010000000000000102030405060708090a0b", "hex");
+var DC_CHROMA = DHT_DC_CHROMA.subarray(0, 5);
+var DHT_AC_CHROMA = Buffer.from("ffc400b51100020102040403040705040400010277000102031104052131061241510761711322328108144291a1b1c109233352f0156272d10a162434e125f11718191a262728292a35363738393a434445464748494a535455565758595a636465666768696a737475767778797a82838485868788898a92939495969798999aa2a3a4a5a6a7a8a9aab2b3b4b5b6b7b8b9bac2c3c4c5c6c7c8c9cad2d3d4d5d6d7d8d9dae2e3e4e5e6e7e8e9eaf2f3f4f5f6f7f8f9fa", "hex");
 var SOI = Buffer.from([255, 216]);
 var APP0 = Buffer.from("ffe000104a46494600010100000100010000", "hex");
 var MCU = { 0: [8, 8], 1: [16, 8], 2: [16, 16] };
@@ -968,16 +977,31 @@ function findGeometry(tail) {
   }
   return best;
 }
+function findScanCut(data) {
+  const sos = data.lastIndexOf(SOS_HEADER);
+  if (sos < 0)
+    return -1;
+  const dri = sos - DRI_SEGMENT.length - 2;
+  return dri >= 0 && data.subarray(dri, dri + DRI_SEGMENT.length).equals(DRI_SEGMENT) ? dri : -1;
+}
+function plaintextTail(data) {
+  const cut = data.indexOf(DC_CHROMA);
+  if (cut >= 0)
+    return data.subarray(cut);
+  const scan = findScanCut(data);
+  if (scan < 0)
+    return null;
+  return Buffer.concat([DHT_DC_CHROMA, DHT_AC_CHROMA, data.subarray(scan)]);
+}
 function isV2Image(data) {
   return data.length >= V2_PREFIX.length && data.subarray(0, V2_PREFIX.length).toString("latin1") === V2_PREFIX;
 }
 function decodeImageV2(data) {
   if (!isV2Image(data))
     return null;
-  const cut = data.indexOf(DC_CHROMA);
-  if (cut < 0)
+  const tail = plaintextTail(data);
+  if (!tail)
     return null;
-  const tail = data.subarray(cut);
   const geometry = findGeometry(tail);
   if (!geometry)
     return null;
@@ -1557,12 +1581,11 @@ var CONTENDED_SESSION_HINT = "the token was rejected again soon after it was las
 function tokenRejected(code, msg) {
   return code === EufyCloudErrorCode.SESSION_KICKED || /user_id is empty|invalid[^,]*\btoken\b|\btoken\b[^,]*(expired|error|not exist)|kicked|(?:\btoken\b|\bsession\b)[^,]*does not exist|unauthor/i.test(msg ?? "");
 }
-function withoutTokenEcho(text2) {
-  return text2.replace(/token\s*[=:]\s*"?[A-Za-z0-9._-]{8,}"?/gi, "token = <redacted>");
-}
 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 +1666,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 +1691,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 +1806,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 +2017,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 +2476,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,
@@ -3034,8 +3089,7 @@ var STATION_TYPES = /* @__PURE__ */ new Set([
   DeviceType.STATION_9000,
   DeviceType.MINIBASE_CHIME,
   DeviceType.HOMEBASE_MINI,
-  DeviceType.NVR_S4_MAX,
-  DeviceType.CAMERA_POE_S4
+  DeviceType.NVR_S4_MAX
 ]);
 var LOCK_TYPES = /* @__PURE__ */ new Set([
   DeviceType.LOCK_BLE,
@@ -3109,7 +3163,7 @@ function codecFromModel(model) {
     return "vacuum";
   if (/^T8(00[0-9]|010|023|025|030)/.test(m))
     return "station";
-  if (/^T8N0/.test(m) || /^T8E0/.test(m))
+  if (/^T8N0/.test(m))
     return "station";
   if (/^T9000/.test(m))
     return "station";
@@ -3280,6 +3334,7 @@ function propertiesOf(members, ctx) {
         raw: m.decode ? true : void 0,
         readAliases: aliases?.slice(promoted ? 1 : 0).map(({ paramType, invert }) => ({ paramType, invert })),
         writable: m.write !== void 0 || m.writtenElsewhere === true,
+        reported: ctx?.paramIds ? wasReported(m, borrowedBy(m, members), { ...ctx, paramIds: ctx.paramIds }) : void 0,
         description: m.description
       }
     ];
@@ -3355,12 +3410,16 @@ function narrow(type, read, prop) {
   return readNum(read, prop);
 }
 function reads(m, ctx) {
-  if (m.realtime === true)
-    return true;
+  return m.realtime === true || sent(m, ctx);
+}
+function sent(m, ctx) {
   if ((!m.readAvailable || m.readAvailable(ctx)) && m.param !== void 0 && ctx.paramIds.has(m.param))
     return true;
   return m.readAliases?.some((a) => (!a.available || a.available(ctx)) && ctx.paramIds.has(a.paramType)) === true;
 }
+function wasReported(m, from, ctx) {
+  return sent(m, ctx) || from !== void 0 && ctx.paramIds.has(from.param);
+}
 function installs(m, ctx) {
   return reports(m.requires, ctx) && (!m.requiresRead || reads(m, ctx)) && (!m.available || m.available(ctx));
 }
@@ -3397,7 +3456,7 @@ function bindMembers(members, deps) {
     const from = borrowedBy(m, members);
     const borrowed = from?.property;
     const available = !m.available || m.available(ctx);
-    const reported = available && (reads(m, ctx) || from !== void 0 && ctx.paramIds.has(from.param));
+    const reported = available && (m.realtime === true || wasReported(m, from, ctx));
     if (reported && !m.writeOnly && !m.unexposed) {
       const decode = m.decode;
       const raw = () => read(prop)?.value ?? (borrowed === void 0 ? void 0 : read(borrowed)?.value);
@@ -4219,6 +4278,10 @@ var MOTION_MEMBERS = {
    * The raw sensitivity an indoor camera reports, on the one id whose write takes a `1700` control
    * payload carrying an index rather than the `1350` envelope its siblings use — a frame-shape
    * difference `sensitivityCommand` resolves from the scale. `unexposed` like its three siblings.
+   *
+   * Some devices report 6041 as a base64 JSON list of per-sensor entries
+   * (`{"list":[{"sensor_id":…,"sensitivity":…}]}`) rather than a scalar. That value is stored verbatim
+   * and this getter answers `undefined` for it: only the scalar form is confirmed to be this step.
    */
   indoorSensitivity: {
     param: MOTION_CMD.INDOOR_SENSITIVITY_INDEX,
@@ -4226,7 +4289,8 @@ var MOTION_MEMBERS = {
     kind: "scalar",
     provenance: "verified",
     unexposed: true,
-    description: "Raw sensitivity an indoor camera reports (verified: param 6041)."
+    description: "Raw sensitivity an indoor camera reports (verified: param 6041).",
+    decode: (raw) => typeof raw === "number" ? raw : void 0
   },
   /**
    * The raw sensitivity on the INVERTED seven-step camera scale — a HIGHER number is LESS sensitive, so
@@ -5060,6 +5124,8 @@ 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 isNvrT8N00 = (ctx) => ctx.model === "T8N00";
 var isAiotVacuum = (ctx) => ctx.category !== "eufy_home_tuya";
 var isTuyaVacuum = (ctx) => ctx.category === "eufy_home_tuya";
 
@@ -5205,6 +5271,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. */
@@ -5448,7 +5516,12 @@ function usesHomeBasePowerPayload(ctx) {
 function hasUnreflectedHomeBasePower(ctx) {
   return usesHomeBasePowerPayload(ctx) && !ctx.paramIds.has(2001);
 }
+function hasPrivacyPower(ctx) {
+  return ctx.deviceType === DeviceType.INDOOR_PT_CAMERA_S350 && ctx.homeBaseAttached === true;
+}
 function powerCommand(on, ctx) {
+  if (hasPrivacyPower(ctx))
+    return privacyCommand(!on, ctx.channel);
   if (usesHomeBasePowerPayload(ctx))
     return setPayload(CAMERA_CMD.PRIVACY_MODE, { switch: on ? 0 : 1 }, ctx, 0);
   return setScalar(CAMERA_CMD.CAMERA_ENABLE, powerValue(on, ctx), ctx, "auto");
@@ -5465,11 +5538,11 @@ function poweredOf(ctx) {
   return cameraPowerTier(ctx.model, ctx.capabilities ?? /* @__PURE__ */ new Set());
 }
 function enablementReflection(on, ctx) {
+  if (!CAMERA_MEMBERS.enabled.readReflectsWrite(ctx))
+    return void 0;
   const alias = CAMERA_MEMBERS.enabled.readAliases[0].paramType;
   if (ctx.paramIds.has(alias))
     return { param: alias, expected: on, observed: on };
-  if (hasUnreflectedHomeBasePower(ctx))
-    return void 0;
   if (ctx.paramIds.has(CAMERA_CMD.CAMERA_ENABLE)) {
     return {
       param: CAMERA_CMD.CAMERA_ENABLE,
@@ -5480,10 +5553,18 @@ function enablementReflection(on, ctx) {
   return void 0;
 }
 function refuseWhenDisabled(ctx, read) {
-  if (!hasUnreflectedHomeBasePower(ctx) && read("enabled")?.value === false)
+  if (CAMERA_MEMBERS.enabled.readReflectsWrite(ctx) && read("enabled")?.value === false)
     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
@@ -5506,7 +5587,7 @@ var CAMERA_MEMBERS = {
     invert: true,
     invertFor: (ctx) => isT8410HomeBase3(ctx) ? false : void 0,
     readAliases: [{ paramType: 2001, invert: false }],
-    readReflectsWrite: (ctx) => !hasUnreflectedHomeBasePower(ctx),
+    readReflectsWrite: (ctx) => !hasUnreflectedHomeBasePower(ctx) && !hasPrivacyPower(ctx),
     description: "Camera enabled. Family-dependent wire param: 1035 CMD_DEVS_SWITCH (enable bit on T8410/HomeBase 3, disable bit on battery/solo cams) or 2001 OPEN_DEVICE (standalone indoor/outdoor). Reported on/off state; unreflectedMembers identifies commands whose effect this report does not reliably reflect.",
     observation: {
       event: "cameraEnabledChanged",
@@ -5640,16 +5721,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 +5736,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
@@ -5829,8 +5913,9 @@ function isStationAlarmOutput(ctx) {
 function isEvidencedStationAlarm(ctx) {
   return isStationAlarmOutput(ctx) && HUB_ALARM_EVIDENCE.some((param) => ctx.paramIds.has(param));
 }
+var S1_PRO_ALARM_MODELS = /* @__PURE__ */ new Set(["T8134"]);
 function isEvidencedAttachedCamera(ctx) {
-  return ctx.codec === "camera" && ctx.homeBaseAttached === true && hasReportedEasSwitch(ctx);
+  return ctx.codec === "camera" && ctx.homeBaseAttached === true && hasReportedEasSwitch(ctx) && (!isStation9000({ deviceType: ctx.stationDeviceType }) || S1_PRO_ALARM_MODELS.has(ctx.model ?? ""));
 }
 function reportsParam(source, param) {
   return source.paramIds?.has(param) === true || Object.hasOwn(source.params ?? {}, param);
@@ -5849,7 +5934,18 @@ function homeBaseAlarm(seconds, ctx) {
     throw new Error("station-family HomeBase alarm output requires the acting account name");
   return setPayload(SIREN_CMD.HOMEBASE_TONE, { time_out: seconds, user_name: ctx.accountName }, ctx, 0, STATION_CHANNEL);
 }
+var PORTAL_MANUAL_ALARM_TYPE = 10;
 function cameraAlarm(seconds, ctx) {
+  if (isStation9000({ deviceType: ctx.stationDeviceType })) {
+    if (!ctx.accountName)
+      throw new Error("a camera alarm behind a HomeBase S1 Pro requires the acting account name");
+    return setPayload(SIREN_CMD.CAMERA_TONE, {
+      time_out: seconds,
+      type: PORTAL_MANUAL_ALARM_TYPE,
+      channel: ctx.channel,
+      username: ctx.accountName
+    }, ctx);
+  }
   return {
     kind: "p2p-int-string",
     cmd: SIREN_CMD.CAMERA_TONE,
@@ -6093,7 +6189,8 @@ var LIGHT_SWITCH_INT_STRING_TYPES = /* @__PURE__ */ new Set([
   DeviceType.CAMERA2_PRO,
   DeviceType.CAMERA2C_PRO,
   DeviceType.CAMERA3,
-  DeviceType.CAMERA3C
+  DeviceType.CAMERA3C,
+  DeviceType.PROFESSIONAL_247
 ]);
 function switchCommand(on, ctx) {
   switch (lightSwitchWire(ctx)) {
@@ -6188,6 +6285,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 +6295,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"
   }
 };
@@ -6588,6 +6688,8 @@ var ZOOM_MODEL_HINT = /^T8170\b|^T8425\b|S340/i;
 function hasZoomEvidence(ctx) {
   return ZOOM_EVIDENCE_PARAMS.some((p) => ctx.paramIds.has(p)) || !!ctx.model && ZOOM_MODEL_HINT.test(ctx.model);
 }
+var PRESET_EVIDENCE_PARAMS = [1029, 6090, 6091, 6092, 6210];
+var FIXED_LENS_MODELS = /* @__PURE__ */ new Set(["T8134"]);
 function rotateCommand(direction, ctx, zoom = 1) {
   return setJson(PTZ_CMD.PTZ_ROTATE, { cmd_type: 1, rotate_type: PTZ_ROTATE[direction], zoom }, ctx);
 }
@@ -6752,8 +6854,9 @@ var PTZ = {
   members: PTZ_MEMBERS,
   properties: propertiesOf(PTZ_MEMBERS),
   // SoloCam proves PT via reported preset params (6090/6091/6092/6210) and a rotate command surface
-  // (1029); Indoor-PT (deviceType 31/35/111 + C220 range 10008-10011) reports NO PT param, so the
-  // vendor deviceType is the only honest signal; explicit PT/S340/S350 model names also prove it.
+  // (1029), except on a FIXED_LENS_MODELS model; Indoor-PT (deviceType 31/35/111 + C220 range
+  // 10008-10011) reports NO PT param, so the vendor deviceType is the only honest signal; explicit
+  // PT/S340/S350 model names also prove it.
   // OUTDOOR_PT_CAMERA (48, e.g. SoloCam S340 / T8170) is pan-tilt by definition but a live unit can
   // report none of the preset params — trust the deviceType. The rotating SoloCam solar variant
   // T8124R shares deviceType 62 with the FIXED T8124 base, so its model code is the only honest
@@ -6761,7 +6864,7 @@ var PTZ = {
   // a `T81\d\dR` wildcard: the "R = rotating" reading is unverified for other models, and an
   // over-broad hint would false-positive a future non-PT model, the same class of bug as a mislabel.
   detection: {
-    evidenceParams: [1029, 6090, 6091, 6092, 6210],
+    detect: (record) => !FIXED_LENS_MODELS.has(record.model ?? "") && PRESET_EVIDENCE_PARAMS.some((p) => Object.hasOwn(record.params ?? {}, p)),
     deviceTypes: [
       DeviceType.OUTDOOR_PT_CAMERA,
       DeviceType.INDOOR_PT_CAMERA,
@@ -6777,7 +6880,7 @@ var PTZ = {
       // no PTZ capability without this, on a real owned unit.
       DeviceType.FLOODLIGHT_CAMERA_8425
     ],
-    modelHints: [/pan.?tilt|\bpt\b|S3[45]0|indoor.?pt/i]
+    modelHints: [/pan.?tilt|\bpt\b|S3[45]0|indoor.?pt/i, /\bT8E00\b/i]
   },
   emits: ["ptzNotify"],
   /**
@@ -7632,7 +7735,8 @@ var ARMING_CMD = {
    */
   SET_ARMING: 1224,
   /**
-   * The per-mode alarm/arm-delay configuration write. ✅ WIRE CAPTURED live on a T8030 (
+   * One guard mode's per-device action table (app `CMD_SET_ALL_ACTION`), which carries the alarm delays
+   * and each device's actions in that mode. ✅ WIRE CAPTURED live on a T8030 (
    * 2026-07-23, both directions): a **bare
    * JSON frame, no `1350`/`1700` envelope** — outer P2P cmd IS `1255` itself, station channel 255,
    * plaintext `{account_id, count_down_alarm:{channel_list,delay_time},
@@ -7649,15 +7753,26 @@ var ARMING_CMD = {
    * corresponding GET command (`1310`/inner cmd `40003`, sent by the app right before editing) always
    * replied `{count:0,data:null}` in every capture — genuinely empty, not a decrypt failure (confirmed
    * via the same bidirectional decrypt this finding used) — so the app does NOT read the current
-   * config this way; how it does is still unknown. Without a working GET, safely PATCHING just one
-   * channel in or out of an existing list isn't possible without risking clobbering the rest — so
+   * config this way; a T8010 reports it on its own params instead, see below. Without a working GET,
+   * safely PATCHING just one channel in or out of an existing list isn't possible without risking
+   * clobbering the rest — so
    * this ships as a caller-supplies-everything write instead of guessing a merge.
    * `devices`/`siren_sensor_action` are even less understood (raw per-device action codes, meaning
    * unconfirmed) and MUST come from a value independently read/captured for the target mode —
    * see `AlarmDelayConfig`'s field docs.
+   *
+   * ✅ On a T8010 the app writes the same command for the Device Control screen: header channel 0, the
+   * whole table of the mode `{mode_id, devices, count_down_alarm, count_down_arm}`, acked by an all-zero
+   * 1255 reply. The T8010 reports each table on its own params, Home on 1157 and Away on 1158, and the
+   * reported table follows a write within 15 s. See {@link DEVICE_NOTIFY_FLAG}.
    */
-  ALARM_DELAY_CONFIG: 1255
+  SET_ALL_ACTION: 1255
 };
+var DEVICE_NOTIFY_FLAG = 8;
+function actionTable(read, mode) {
+  const value = read(`${mode}ActionTable`)?.value;
+  return value && typeof value === "object" && Array.isArray(value.devices) ? value : void 0;
+}
 var ARMING_MODE_WIRE = {
   away: 0,
   home: 1,
@@ -7694,7 +7809,15 @@ function alarmDelayCommand(mode, config, ctx) {
     devices: config.devices.map((d) => ({ action: d.action, device_channel: d.deviceChannel })),
     siren_sensor_action: config.sirenSensorAction.map((d) => ({ action: d.action, device_channel: d.deviceChannel }))
   };
-  return setJsonRaw(ARMING_CMD.ALARM_DELAY_CONFIG, data, ctx, STATION_CHANNEL2);
+  return setJsonRaw(ARMING_CMD.SET_ALL_ACTION, data, ctx, STATION_CHANNEL2);
+}
+var ACTION_TABLE_LAG_MS = 15e3;
+function withDeviceNotification(table, channel, on) {
+  if (!table?.devices.some((d) => d.device_channel === channel))
+    return void 0;
+  const { account_id: _account, ...rest } = table;
+  const devices = table.devices.map((d) => d.device_channel === channel ? { ...d, action: on ? d.action | DEVICE_NOTIFY_FLAG : d.action & ~DEVICE_NOTIFY_FLAG } : d);
+  return { ...rest, devices };
 }
 var ARMING_MEMBERS = {
   /**
@@ -7752,8 +7875,50 @@ var ARMING_MEMBERS = {
     } catch (e) {
       return Promise.reject(e);
     }
-  }, "Write the full per-mode alarm/arm-delay configuration.")
+  }, "Write the full per-mode alarm/arm-delay configuration."),
+  /**
+   * Whether the device on `channel` sends a push notification in `mode`: its {@link DEVICE_NOTIFY_FLAG}
+   * in the action table the station reports for that mode. `undefined` where the station reports no table
+   * or the table does not list `channel`. A device's channel is `EufyDevice.channel`.
+   */
+  deviceNotification: method(({ read }) => (mode, channel) => {
+    const action = actionTable(read, mode)?.devices.find((d) => d.device_channel === channel)?.action;
+    return typeof action === "number" ? (action & DEVICE_NOTIFY_FLAG) !== 0 : void 0;
+  }, "Whether the device on a channel sends a push notification in a guard mode (home/away).", (ctx) => ctx.model === "T8010"),
+  /**
+   * Turn the push notification of the device on `channel` on or off in `mode` (cmd
+   * {@link ARMING_CMD.SET_ALL_ACTION}): the station's reported table written back with that one flag
+   * changed. Rejects, sending nothing, where the table does not list `channel`. A write builds on the last
+   * one sent for that mode until the station reports a table observed 15 s after it, so a second write does
+   * not revert it; a write whose dispatch rejects is not built on.
+   */
+  setDeviceNotification: method(({ ctx, sink, read }) => {
+    const sent2 = /* @__PURE__ */ new Map();
+    return (mode, channel, on) => {
+      const last = sent2.get(mode);
+      const observed = read(`${mode}ActionTable`)?.ts ?? 0;
+      const base = last && observed < last.at + ACTION_TABLE_LAG_MS ? last.table : actionTable(read, mode);
+      const table = withDeviceNotification(base, channel, on);
+      if (!table) {
+        return Promise.reject(new Error(`arming: no ${mode} action table lists channel ${channel} [${describeDevice(ctx)}]`));
+      }
+      sent2.set(mode, { table, at: Date.now() });
+      return sink.dispatch(setJsonRaw(ARMING_CMD.SET_ALL_ACTION, table, ctx, 0)).catch((err) => {
+        if (sent2.get(mode)?.table === table) {
+          if (last)
+            sent2.set(mode, last);
+          else
+            sent2.delete(mode);
+        }
+        throw err;
+      });
+    };
+  }, "Turn the push notification of the device on a channel on or off in a guard mode (home/away).", (ctx) => ctx.model === "T8010")
 };
+function decodeAlarmPhase(signal) {
+  const type = signal.source === "push" ? signal.payload?.["type"] : void 0;
+  return type === CusPushAlarmType.HUB_STOP_BY_APP ? { phase: "stopped" } : {};
+}
 var ARMING = {
   capability: "arming",
   description: "Station/device guard (arming) mode.",
@@ -7768,8 +7933,9 @@ var ARMING = {
    * generic `CusPushEvent` channel, so these ids are shared with other families and resolve by
    * capability (see the barrel's event index).
    *
-   * The alarm ids carry a static `phase` so one event name covers the whole lifecycle, the same shape
-   * `battery` uses for its threshold pushes. The mode-switch push is known to identify WHICH mode and
+   * The alarm ids carry a `phase` so one event name covers the whole lifecycle: the countdown push a
+   * static `"delayed"`, the alarm push a `"triggered"` or `"stopped"` read from its alarm type (see
+   * {@link decodeAlarmPhase}). The mode-switch push is known to identify WHICH mode and
    * what triggered the change, but neither has been observed on the wire here, so this emits the bare
    * transition and refreshes the `mode` read rather than trusting a decoded field.
    */
@@ -7780,7 +7946,13 @@ var ARMING = {
       emit: "armingModeChanged",
       refresh: { member: "mode" }
     },
-    { source: "push", match: CusPushEvent.ALARM, emit: "alarm", payload: { phase: "triggered" } },
+    {
+      source: "push",
+      match: CusPushEvent.ALARM,
+      emit: "alarm",
+      payload: { phase: "triggered" },
+      derive: decodeAlarmPhase
+    },
     { source: "push", match: CusPushEvent.ALARM_DELAY, emit: "alarm", payload: { phase: "delayed" } }
   ]
 };
@@ -8312,8 +8484,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 +8507,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 +8545,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 +8592,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 +10444,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. */
@@ -10392,6 +10568,11 @@ var SuctionLevel = {
 };
 var SUCTION_LABEL = enumLabels(SuctionLevel);
 var ALL_SUCTION_LEVELS = [0, 1, 2, 3, 4, 5];
+function levelFromCatalog(member) {
+  if (Object.hasOwn(SuctionLevel, member))
+    return SuctionLevel[member];
+  return Object.hasOwn(SUCTION_LABEL, member) ? Number(member) : void 0;
+}
 function suctionLevelName(value) {
   return SUCTION_LABEL[value];
 }
@@ -10452,13 +10633,15 @@ var SUCTION = {
   },
   /**
    * The per-model level range — sourced from the SKU's `get_product_data_point` catalog for DP 158
-   * when available. `undefined` when no catalog entry exists for DP 158. `setSuctionLevel` is only
+   * when available. `undefined` when no catalog entry exists for DP 158, or when no listed member maps
+   * to a known level (so a caller never reads `[]` as "nothing selectable"). `setSuctionLevel` is only
    * installed on AIoT devices (gated by `available: isAiotVacuum` on the `level` entry), so
    * `supportedLevels` is harmless data on a non-AIoT device.
    */
   actions({ ctx }) {
     const catalogRange = ctx.dpCatalog?.enumRanges.get(SUCTION_DP.SUCTION);
-    const supportedLevels = catalogRange?.filter((v) => v in SUCTION_LABEL);
+    const levels = catalogRange?.flatMap((m) => levelFromCatalog(m) ?? []);
+    const supportedLevels = levels?.length ? levels : void 0;
     return { supportedLevels };
   }
 };
@@ -10500,28 +10683,29 @@ function parseEnumRange(values) {
   if (values === null || values === void 0)
     return [];
   if (Array.isArray(values))
-    return toNumberArray(values);
+    return toMemberArray(values);
   if (typeof values === "string") {
     try {
       const parsed = JSON.parse(values);
       if (Array.isArray(parsed))
-        return toNumberArray(parsed);
+        return toMemberArray(parsed);
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const obj = parsed;
         if (Array.isArray(obj.range))
-          return toNumberArray(obj.range);
+          return toMemberArray(obj.range);
       }
     } catch {
     }
   }
   return [];
 }
-function toNumberArray(arr) {
+function toMemberArray(arr) {
   const result = [];
   for (const v of arr) {
-    const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
-    if (Number.isInteger(n))
-      result.push(n);
+    if (typeof v === "number" && Number.isFinite(v))
+      result.push(String(v));
+    else if (typeof v === "string" && v !== "")
+      result.push(v);
   }
   return result;
 }
@@ -11016,8 +11200,12 @@ var MODEL_REGISTRY = {
   // Cameras with curated extras that aren't always provable from a fresh device's params.
   T8423: { codec: "camera", caps: ["light", "battery"], name: "Floodlight Cam" },
   T8210: { codec: "camera", caps: ["doorbell", "battery"], name: "Video Doorbell" },
+  // T8210 hardware variant, reported as its own code; shares the T8210 row.
+  T8210C: { 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
@@ -11038,6 +11226,8 @@ var MODEL_REGISTRY = {
   // shows a parent, so an attached cam never advertises the hub's guard mode.
   T8170: { codec: "camera", caps: ["battery", "arming"], name: "SoloCam" },
   T8171: { codec: "camera", caps: ["battery", "arming"], name: "T8171" },
+  // Baby Monitor E21, vendor deviceType 86 (category eufy_care), standalone.
+  T8354: { codec: "camera", name: "Baby Monitor E21" },
   T8400: { codec: "camera", caps: ["arming"], name: "Indoor Cam" },
   T8410: { codec: "camera", caps: ["arming"], name: "Indoor Cam Pan & Tilt" },
   T8442: { codec: "camera", caps: ["arming"], name: "Indoor/Outdoor Cam 1080p" },
@@ -11179,8 +11369,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);
@@ -11380,9 +11572,15 @@ var SECURITY_PARAMS = {
     provenance: "guessed"
   },
   1157: {
-    name: "jsDelayHome",
+    name: "homeActionTable",
     type: "string",
-    provenance: "apk",
+    provenance: "verified",
+    encoding: "base64+json"
+  },
+  1158: {
+    name: "awayActionTable",
+    type: "string",
+    provenance: "verified",
     encoding: "base64+json"
   },
   1159: {
@@ -13006,7 +13204,7 @@ function coerce(spec, raw, invert = false, logger = noopLogger) {
 function sameManifest(a, b) {
   if (a.length !== b.length)
     return false;
-  const sig = (p) => JSON.stringify([p.name, p.writable, p.enumValues ?? null]);
+  const sig = (p) => JSON.stringify([p.name, p.writable, p.reported ?? null, p.enumValues ?? null]);
   const bSigs = new Set(b.map(sig));
   return a.every((p) => bSigs.has(sig(p)));
 }
@@ -14383,6 +14581,19 @@ function decodeMapFrame(frame, codec) {
   return READERS.get(frame.channelId)?.(frame.payload, codec);
 }
 
+// dist/transport/abortable.js
+function abortable(work, signal) {
+  if (!signal)
+    return work;
+  signal.throwIfAborted();
+  return Promise.race([
+    work,
+    new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+    })
+  ]);
+}
+
 // dist/transport/p2p/command-router.js
 import { setTimeout as sleep2 } from "node:timers/promises";
 
@@ -15308,7 +15519,7 @@ var PADDED_RESULT_BYTES = 132;
 var CMD_CAMERA_INFO = 1103;
 var CMD_DATABASE_IMAGE = 1308;
 var CMD_DATABASE = 1306;
-var DB_QUERY = { FULL_TABLE: 1e4, COMBINATION_WITH_AI: 10011 };
+var DB_QUERY = { FULL_TABLE: 1e4, COMBINATION_WITH_AI: 10011, QUERY_LOCAL: 10017 };
 var GCM_AAD = Buffer.from("eufy security");
 var LEVEL2_SEQ_BASE = 16909056;
 function paramReport(payload) {
@@ -15338,9 +15549,13 @@ function firstTableRows(text2) {
     } catch {
       continue;
     }
-    const data = parsed?.data;
-    if (Array.isArray(data))
-      return data;
+    const reply = parsed;
+    if (typeof reply?.mIntRet === "number" && reply.mIntRet !== 0)
+      return { error: reply.mIntRet };
+    if (reply?.data === "[]")
+      return { rows: [] };
+    if (Array.isArray(reply?.data))
+      return { rows: reply.data };
   }
   return void 0;
 }
@@ -15699,8 +15914,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 +15931,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() {
@@ -15888,6 +16104,9 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       }
     } else if (hasHeader(msg, ResponseMessageType.CAM_ID) || hasHeader(msg, ResponseMessageType.TURN_SERVER_CAM_ID)) {
       this.onConnected({ host: rinfo.address, port: rinfo.port }, socket);
+    } else if (hasHeader(msg, ResponseMessageType.END)) {
+      if (fromConnectedPeer)
+        void this.close().catch((error) => this.emit("error", error));
     } else if (hasHeader(msg, ResponseMessageType.PONG)) {
       this.lastPongData = msg.length > 4 ? msg.subarray(4) : void 0;
     } else if (hasHeader(msg, ResponseMessageType.PING)) {
@@ -15961,6 +16180,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       socket.removeAllListeners("error");
       socket.on("error", (error) => this.emit("error", error));
       this.socket = socket;
+      this.requestReceiveBuffer(socket);
     }
     this.connected = true;
     this.connectedAtMs = Date.now();
@@ -16248,6 +16468,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 +16703,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({
@@ -16684,6 +16919,29 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       query: this.fullTableQuery()
     });
   }
+  /**
+   * Read a date-ranged page of `history_record_info` from the station. The reply's `data` array groups
+   * recording rows with companion tables; each group retains its `table_name` and `payload`.
+   * `startTime` is `"0"` for the newest page or the oldest row's `yyyyMMddHHmmss` cursor for older rows.
+   */
+  queryRecordPage(opts) {
+    return this.readDatabase("history_record_info", {
+      accountId: opts.accountId,
+      innerCmd: DB_QUERY.QUERY_LOCAL,
+      query: {
+        count: opts.count ?? 20,
+        start_date: opts.startDate,
+        end_date: opts.endDate,
+        start_time: opts.startTime ?? "0",
+        event_type: 0,
+        ai_type: 0,
+        storage_cloud: -1,
+        trigger_type: 0,
+        detection_type: 0,
+        flag: 0
+      }
+    });
+  }
   /**
    * Query one on-station table and answer its rows, once the reply is whole.
    *
@@ -16691,7 +16949,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * several frames whose decrypted text is a fragment of one document, so the fragments are
    * accumulated here and scanned after each one. Answers that document's `data` rows. Rejects when
    * `signal` aborts, and when `timeoutMs` (default {@link DB_TABLE_TIMEOUT_MS}) elapses with no
-   * complete reply.
+   * complete reply, and when the station answers a non-zero `mIntRet`.
    *
    * One read at a time per session: while one is accumulating, every {@link queryDatabase} on the
    * session throws, so a second reply cannot land in this buffer.
@@ -16699,16 +16957,22 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   async readDatabase(table, opts = {}) {
     if (opts.signal?.aborted)
       throw new Error("readDatabase: aborted");
-    this.queryDatabase(table, { accountId: opts.accountId, query: this.fullTableQuery() });
+    this.queryDatabase(table, {
+      accountId: opts.accountId,
+      innerCmd: opts.innerCmd,
+      query: opts.query ?? this.fullTableQuery()
+    });
     this.dbReadInFlight = true;
     try {
       return await new Promise((resolve, reject) => {
         let text2 = "";
         const onChunk = (chunk) => {
           text2 += chunk.text;
-          const rows = firstTableRows(text2);
-          if (rows)
-            settle(() => resolve(rows));
+          const result = firstTableRows(text2);
+          if (result?.error !== void 0)
+            settle(() => reject(new Error(`readDatabase: ${table} refused: ${result.error}`)));
+          else if (result?.rows)
+            settle(() => resolve(result.rows));
         };
         const timer = setTimeout(() => settle(() => reject(new Error(`readDatabase: ${this.cfg.stationSn} sent no complete ${table}`))), opts.timeoutMs ?? DB_TABLE_TIMEOUT_MS);
         const onAbort = () => settle(() => reject(new Error("readDatabase: aborted")));
@@ -16809,11 +17073,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 +17145,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);
@@ -16900,32 +17168,35 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * Frames are packed back to back, so a frame header can itself be cut by a datagram boundary. The start
    * of a header left at the end of a datagram is carried into the next one rather than discarded; dropping
    * it would lose that frame and every frame after it until a datagram happened to begin on a header.
+   * Payload fragments retain their original slices and are copied once, when the complete frame is delivered.
    */
   reassemble(dataType, datagramBody) {
     const pending = this.pendingByDataType.get(dataType);
-    let body = pending ? Buffer.concat([pending.buf, datagramBody]) : datagramBody;
-    const carryHeader = pending?.header;
     this.pendingByDataType.delete(dataType);
-    if (carryHeader) {
-      if (body.length < carryHeader.bytesToRead) {
-        this.pendingByDataType.set(dataType, { header: carryHeader, buf: body });
+    let body = pending && !pending.header ? Buffer.concat([...pending.chunks, datagramBody]) : datagramBody;
+    if (pending?.header) {
+      const taken = Math.min(pending.header.bytesToRead - pending.byteLength, body.length);
+      pending.chunks.push(body.subarray(0, taken));
+      pending.byteLength += taken;
+      body = body.subarray(taken);
+      if (pending.byteLength < pending.header.bytesToRead) {
+        this.pendingByDataType.set(dataType, pending);
         return;
       }
-      this.handleFrame(carryHeader, body.subarray(0, carryHeader.bytesToRead), dataType);
-      body = body.subarray(carryHeader.bytesToRead);
+      this.handleFrame(pending.header, Buffer.concat(pending.chunks, pending.byteLength), dataType);
     }
     while (body.length >= P2P_DATA_HEADER_BYTES && body.subarray(0, 4).toString() === MAGIC_WORD) {
       const header = parseDataFrameHeader(body);
       const payload = body.subarray(P2P_DATA_HEADER_BYTES);
       if (payload.length < header.bytesToRead) {
-        this.pendingByDataType.set(dataType, { header, buf: payload });
+        this.pendingByDataType.set(dataType, { header, chunks: [payload], byteLength: payload.length });
         return;
       }
       this.handleFrame(header, payload.subarray(0, header.bytesToRead), dataType);
       body = body.subarray(P2P_DATA_HEADER_BYTES + header.bytesToRead);
     }
     if (body.length > 0 && body.length < P2P_DATA_HEADER_BYTES && MAGIC_WORD.startsWith(body.subarray(0, 4).toString())) {
-      this.pendingByDataType.set(dataType, { buf: body });
+      this.pendingByDataType.set(dataType, { chunks: [body], byteLength: body.length });
     }
   }
   /**
@@ -17518,7 +17789,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 +17810,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 [];
@@ -17563,7 +17837,13 @@ function beginsAccessUnit(body) {
   return body[2] === 1 || body[2] === 0 && body[3] === 1;
 }
 function unitOf(header, data) {
-  return { keyframe: header.keyframe, width: header.width, height: header.height, data };
+  return {
+    sourceTimestamp: header.timestamp,
+    keyframe: header.keyframe,
+    width: header.width,
+    height: header.height,
+    data
+  };
 }
 
 // dist/transport/p2p/annexb.js
@@ -17666,6 +17946,18 @@ function startCodeBegin(buf, payloadOffset) {
     return threeByte - 1;
   return threeByte;
 }
+function hasIdr(buf, codec) {
+  for (const p of nalStarts(buf)) {
+    const b = buf[p];
+    if (codec === "h265") {
+      const t = b >> 1 & 63;
+      if (t === 19 || t === 20)
+        return true;
+    } else if ((b & 31) === 5)
+      return true;
+  }
+  return false;
+}
 var MAX_CODED_DIMENSION = 32768;
 var H264_CHROMA_PROFILES = /* @__PURE__ */ new Set([100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134, 135, 144]);
 var CHROMA_SUBSAMPLING = {
@@ -17878,6 +18170,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 +18184,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 +18232,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 +18330,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 +18367,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 });
@@ -18077,6 +18384,7 @@ var LiveStream = class extends EventEmitter3 {
             this.lastCodec = sniffAnnexbCodec(unit.data) ?? this.lastCodec;
           this.settleKeepalive();
           this.emit("video", {
+            sourceTimestamp: unit.sourceTimestamp,
             keyframe: unit.keyframe,
             width: unit.width,
             height: unit.height,
@@ -18092,7 +18400,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 +18467,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);
@@ -18572,9 +18881,11 @@ function decodeRecording(frames, eccPrivateKeyHex) {
   if (eccPrivateKey.length !== 32)
     throw new RecordingDownloadError("undecodable", "the cipher key is not a P-256 key");
   const decoder = new VideoFrameDecoder(eccPrivateKey);
+  const assembler = new AccessUnitAssembler();
   const video = [];
   const audio = [];
   const numbers = /* @__PURE__ */ new Set();
+  const receivedNumbers = /* @__PURE__ */ new Set();
   let firstStamp;
   let lastStamp;
   for (const { commandId, raw } of frames) {
@@ -18582,14 +18893,15 @@ function decodeRecording(frames, eccPrivateKeyHex) {
       const header = parseVideoFrameHeader(raw);
       if (!header)
         continue;
-      const h264 = header.keyframe ? decoder.decodeFrame(raw)?.h264 : raw.length >= VIDEO_HEADER_LEN2 + header.payloadLength ? raw.subarray(VIDEO_HEADER_LEN2, VIDEO_HEADER_LEN2 + header.payloadLength) : void 0;
-      if (!h264?.length)
-        continue;
-      video.push(h264);
-      numbers.add(header.sequence);
-      const stamp = raw.readUIntLE(14, 6);
-      firstStamp ??= stamp;
-      lastStamp = stamp;
+      receivedNumbers.add(header.sequence);
+      const units = assembler.push(raw, (payload) => header.keyframe ? decoder.decodeFrame(payload)?.h264 : payload.length >= VIDEO_HEADER_LEN2 + header.payloadLength ? payload.subarray(VIDEO_HEADER_LEN2, VIDEO_HEADER_LEN2 + header.payloadLength) : void 0);
+      for (const unit of units) {
+        video.push(unit.data);
+        numbers.add(header.sequence);
+        const stamp = raw.readUIntLE(14, 6);
+        firstStamp ??= stamp;
+        lastStamp = stamp;
+      }
     } else if (commandId === CommandType.CMD_AUDIO_FRAME) {
       const mediaKey = decoder.currentMediaKey;
       if (!mediaKey || raw.length < AUDIO_BODY_START || raw[5] !== AUDIO_CODEC_AAC_LC)
@@ -18605,9 +18917,10 @@ function decodeRecording(frames, eccPrivateKeyHex) {
   if (!video.length)
     throw new RecordingDownloadError("undecodable", "no video frame of the recording decoded");
   const ordered = [...numbers];
-  let missingFrames = 0;
-  for (let i = 1; i < ordered.length; i++) {
-    const step = ordered[i] - ordered[i - 1] & 65535;
+  const received = [...receivedNumbers];
+  let missingFrames = receivedNumbers.size - numbers.size;
+  for (let i = 1; i < received.length; i++) {
+    const step = received[i] - received[i - 1] & 65535;
     if (step > 1 && step < 32768)
       missingFrames += step - 1;
   }
@@ -19415,6 +19728,14 @@ var SharedLiveSource = class {
       this.opts.onIdle?.();
   }
 };
+function attachUnlessAborted(source, signal) {
+  const consumer = source.attach();
+  if (signal?.aborted) {
+    consumer.detach();
+    signal.throwIfAborted();
+  }
+  return consumer;
+}
 
 // dist/transport/p2p/session-manager.js
 var SessionSupersededError = class extends Error {
@@ -19828,7 +20149,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 +20158,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 +20185,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 +20201,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 +20241,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 +20318,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 +20383,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 +20456,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 {
@@ -20124,9 +20471,12 @@ var Fmp4Muxer = class {
   fragTicks = 0;
   // ticks accumulated in the open fragment
   samples = [];
-  lastVideoTimestampMs;
+  /** Ticks from the first video sample's start to the newest sample's end, at its provisional duration. */
+  videoTicks = 0;
   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;
@@ -20146,6 +20496,10 @@ var Fmp4Muxer = class {
    * Push one access unit. Returns any completed segments: the `init` on the first keyframe, and/or a
    * media fragment when this frame closed the open one. Returns `undefined` if nothing is emitted yet
    * (e.g. delta frames before the first keyframe).
+   *
+   * A sample lasts until the next frame's `timestampMs`, measured from the first keyframe's, so the video
+   * timeline follows the arrival clock; a frame that shares the previous one's timestamp leaves that
+   * sample one tick long, and the next frame's duration absorbs the difference.
    */
   push(frame, timestampMs = now()) {
     if (frame.codec === "av1")
@@ -20164,15 +20518,14 @@ var Fmp4Muxer = class {
       this.height = declared?.height ?? frame.height;
       this.firstVideoTimestampMs = timestampMs;
     }
-    if (this.lastVideoTimestampMs !== void 0 && this.samples.length) {
-      const measured = Math.round((timestampMs - this.lastVideoTimestampMs) * (TIMESCALE / 1e3));
-      if (measured > 0) {
-        const previous = this.samples[this.samples.length - 1];
-        this.fragTicks += measured - previous.duration;
-        previous.duration = measured;
-      }
+    if (this.firstVideoTimestampMs !== void 0 && this.samples.length) {
+      const previous = this.samples[this.samples.length - 1];
+      const arrival = Math.round((timestampMs - this.firstVideoTimestampMs) * (TIMESCALE / 1e3));
+      const duration = Math.max(1, arrival - (this.videoTicks - previous.duration));
+      this.fragTicks += duration - previous.duration;
+      this.videoTicks += duration - previous.duration;
+      previous.duration = duration;
     }
-    this.lastVideoTimestampMs = timestampMs;
     let fragment;
     if (frame.keyframe && this.samples.length > 0 && this.fragTicks >= this.fragmentTicks) {
       if (!this.initSent) {
@@ -20184,6 +20537,7 @@ var Fmp4Muxer = class {
     }
     this.samples.push({ data: annexbToAvcc(frame.data), duration: this.firstDuration, keyframe: frame.keyframe });
     this.fragTicks += this.firstDuration;
+    this.videoTicks += this.firstDuration;
     if (!this.initSent && (!this.audioRequested || this.audioCodec || this.audioDisabled)) {
       init = this.buildInit();
       this.initSent = true;
@@ -20193,7 +20547,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 +20566,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 +20590,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 +20863,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]));
@@ -20704,16 +21068,12 @@ function stationOf(dev) {
   const parent = typeof raw.parent_sn === "string" && raw.parent_sn && raw.parent_sn !== dev.sn ? raw.parent_sn : void 0;
   return parent ?? dev.stationSn ?? resolvedStationSn(raw, dev.sn);
 }
-function statedChannel(dev) {
-  const v = dev.raw?.device_channel;
-  return typeof v === "number" ? v : void 0;
-}
 function stationChannels(devices) {
   const out = /* @__PURE__ */ new Map();
   const claimants = /* @__PURE__ */ new Map();
   for (const d of devices) {
     const station = stationOf(d);
-    const stated = statedChannel(d);
+    const stated = d.channel;
     if (d.sn === station || stated === void 0)
       continue;
     const counts = claimants.get(station) ?? /* @__PURE__ */ new Map();
@@ -20722,7 +21082,7 @@ function stationChannels(devices) {
   }
   for (const d of devices) {
     const station = stationOf(d);
-    const stated = statedChannel(d);
+    const stated = d.channel;
     if (d.sn === station)
       out.set(d.sn, { channel: stated ?? 0 });
     else if (stated === void 0)
@@ -20737,17 +21097,6 @@ function stationChannels(devices) {
 
 // dist/transport/p2p/command-router.js
 var DIRECT_CMD_SENDS = 5;
-function abortable(work, signal) {
-  if (!signal)
-    return work;
-  signal.throwIfAborted();
-  return Promise.race([
-    work,
-    new Promise((_resolve, reject) => {
-      signal.addEventListener("abort", () => reject(signal.reason), { once: true });
-    })
-  ]);
-}
 var LEVEL2_GRACE_MS = 25e3;
 var LEVEL2_SETTLE_MS = 8e3;
 var P2P_STATION_WAITS = {
@@ -20756,6 +21105,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 +21547,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`.
@@ -21209,11 +21588,11 @@ var P2PCommandRouter = class _P2PCommandRouter {
       },
       live: async (opts) => {
         const source = await this.sharedLiveSourceFor(sn, opts, true);
-        return this.attachUnlessAborted(source, opts?.signal);
+        return attachUnlessAborted(source, opts?.signal);
       },
       openReadable: async (opts) => {
         const source = await this.sharedLiveSourceFor(sn, opts ?? {}, true);
-        return openReadableFromConsumer(this.attachUnlessAborted(source, opts?.signal), opts);
+        return openReadableFromConsumer(attachUnlessAborted(source, opts?.signal), opts);
       },
       recordFragments: (opts) => this.recordFragments(sn, opts),
       talkback: (opts) => this.openTalkback(sn, opts),
@@ -21303,6 +21682,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 +21756,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);
@@ -21572,22 +21960,6 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * A still with no live sibling re-asserts, so a tile refreshing on a quiet station is
    * unaffected.
    */
-  /**
-   * Attach a consumer, unless the caller has already abandoned the call.
-   *
-   * The acquisition it just waited through can outlast the caller's interest, and a consumer attached for
-   * somebody who has gone keeps the pull warm for nobody. Detaching immediately gives the pull back, which
-   * lets it linger and fall away if this was the only thing holding it, and leaves it untouched if it was
-   * not.
-   */
-  attachUnlessAborted(source, signal) {
-    const consumer = source.attach();
-    if (signal?.aborted) {
-      consumer.detach();
-      signal.throwIfAborted();
-    }
-    return consumer;
-  }
   /**
    * Dispose one cached live source and forget it, so the next acquisition builds a fresh one. Its claim
    * on a session goes with it, and a media session opened for this source alone is closed: nothing else
@@ -21648,8 +22020,10 @@ var P2PCommandRouter = class _P2PCommandRouter {
   tearDownStation(stationSn) {
     this.manager.remove(stationSn);
     for (const key of [...this.liveSources.keys()]) {
-      if (key.startsWith(`${stationSn}:`))
+      const owner = this.liveSessionKeys.get(key);
+      if (key.startsWith(`${stationSn}:`) && !(owner && _P2PCommandRouter.isMediaSessionKey(owner))) {
         this.dropLiveSource(key);
+      }
     }
     for (const [key, talk] of this.talkbacks) {
       if (key.startsWith(`${stationSn}:`)) {
@@ -22048,13 +22422,13 @@ var P2PCommandRouter = class _P2PCommandRouter {
    */
   async replayLevel2Send(sn, describe2, send, resolved) {
     resolved ??= await this.resolveSession(sn, { waitLevel2: true });
-    let sent = false;
+    let sent2 = false;
     for (let i = 0; i < DIRECT_CMD_SENDS; i++) {
       if (send(resolved))
-        sent = true;
+        sent2 = true;
       await sleep2(200);
     }
-    if (!sent) {
+    if (!sent2) {
       throw new Error(`${describe2} for ${sn} was never sent (no level-2 key / session not connected)`);
     }
   }
@@ -22085,7 +22459,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * **`set-json-raw` intent** — bare JSON, no envelope: outer P2P cmd = `outerCmd` itself, plaintext
    * exactly `{account_id,...data}` (`session.sendRawLevel2` with no wrapper). Reversed from a live
    * capture of the app's own SET_SNOOZE_TIME (1271) frame — see `param-dictionary.ts`'s `1271` entry
-   * (`snoozeTime`); the alarm-delay config (1255, `arming.ts`'s `ARMING_CMD.ALARM_DELAY_CONFIG`) reuses
+   * (`snoozeTime`); the alarm-delay config (1255, `arming.ts`'s `ARMING_CMD.SET_ALL_ACTION`) reuses
    * the same bare-JSON shape.
    */
   async sendJsonRaw(sn, outerCmd, data, channel) {
@@ -22357,86 +22731,1722 @@ var P2PCommandRouter = class _P2PCommandRouter {
   }
 };
 
-// dist/transport/mqtt/command-router.js
-import { randomBytes as randomBytes3 } from "node:crypto";
+// dist/transport/rtc/live.js
+import { EventEmitter as EventEmitter7 } from "node:events";
 
-// dist/transport/mqtt/broker-discovery.js
-import { resolve4 } from "node:dns/promises";
-async function resolveBrokerIps(hostname) {
+// dist/transport/rtc/portal-keepalive.js
+var PORTAL_KEEPALIVE = Buffer.from("0009000010000000000000006300000000000000585a5948730400000000000000000002", "hex");
+var PORTAL_KEEPALIVE_MS = 29e3;
+
+// dist/transport/rtc/portal-packet.js
+var MAGIC2 = Buffer.from("XZYH", "ascii");
+var PORTAL_HEADER_LENGTH = 16;
+var PORTAL_CMD_SET_PAYLOAD = 1350;
+var PORTAL_STATION_CHANNEL = 255;
+var PortalLinkType = {
+  /** Command channel: requests out, acknowledgements back. */
+  COMMAND: 1,
+  /** Station-originated frames: pushes, notify payloads, control results. */
+  NOTIFY: 3,
+  /** Live video. */
+  LIVE: 5
+};
+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 await resolve4(hostname);
+    return JSON.parse(text2);
   } catch {
-    return [];
+    return text2;
   }
 }
-function mergeCandidateIps(dnsIps, extraIps = []) {
-  return Array.from(/* @__PURE__ */ new Set([...dnsIps, ...extraIps]));
-}
-function rankResults(results) {
-  return [...results].sort((a, b) => Number(b.granted) - Number(a.granted));
-}
-async function probeBrokerInstance(ip, creds, opts) {
-  const mqtt = await loadMqtt();
-  const start = Date.now();
-  const timeoutMs = opts.timeoutMs ?? 8e3;
-  return await new Promise((resolvePromise) => {
-    let settled = false;
-    const finish = (r) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      try {
-        client.end(true);
-      } catch {
-      }
-      resolvePromise({ ip, ms: Date.now() - start, ...r });
+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
     };
-    const client = mqtt.connect({
-      host: ip,
-      port: creds.port ?? 8883,
-      protocol: "mqtts",
-      ...bareIpTlsOptions({
-        hostname: creds.hostname,
-        cert: creds.certificate_pem,
-        key: creds.private_key,
-        ca: creds.aws_root_ca1_pem
-      }),
-      clientId: opts.clientId,
-      protocolVersion: 4,
-      keepalive: 60,
-      clean: true,
-      reconnectPeriod: 0,
-      connectTimeout: timeoutMs
-    });
-    const timer = setTimeout(() => finish({ granted: false, error: "timeout" }), timeoutMs);
-    client.on("connect", () => {
-      client.subscribe(opts.topic, { qos: 1 }, (err, granted) => {
-        if (err)
-          return finish({ granted: false, error: err.message });
-        const g = granted?.[0];
-        const denied = !g || g.qos === 128;
-        finish({ granted: !denied, grantedQos: g?.qos });
-      });
-    });
-    client.on("error", (err) => finish({ granted: false, error: err.message }));
-  });
-}
-async function discoverReachableInstance(creds, opts) {
-  const dnsIps = await resolveBrokerIps(creds.hostname);
-  const all = mergeCandidateIps(dnsIps, opts.candidateIps);
-  const results = [];
-  for (const ip of all) {
-    const r = await probeBrokerInstance(ip, creds, {
-      clientId: opts.clientIdFor(ip),
-      topic: opts.topic,
-      timeoutMs: opts.perAttemptTimeoutMs
-    });
-    results.push(r);
-    if (r.granted && opts.stopOnFirstGrant)
-      break;
   }
-  return rankResults(results);
+  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/live.js
+var LIVE_START = 1003;
+var LIVE_STOP = 1004;
+var LIVE_MEDIA = 1300;
+var LIVE_MEDIA_CHANNEL = 101;
+var LIVE_STREAM_ID = 1;
+var MEDIA_HEADER_LENGTH = 22;
+var STREAM_TYPE_HEVC = 1;
+function parseMediaBody(body) {
+  if (body.length < MEDIA_HEADER_LENGTH || body[5] !== STREAM_TYPE_HEVC)
+    return void 0;
+  const length = body.readUInt32LE(0);
+  if (body.length < MEDIA_HEADER_LENGTH + length)
+    return void 0;
+  return {
+    data: body.subarray(MEDIA_HEADER_LENGTH, MEDIA_HEADER_LENGTH + length),
+    width: body.readUInt16LE(10),
+    height: body.readUInt16LE(12)
+  };
+}
+var RtcLiveStream = class extends EventEmitter7 {
+  opts;
+  running = false;
+  startSegment = -1;
+  keepalive;
+  width = 0;
+  height = 0;
+  onMedia = (frame) => this.onMediaFrame(frame);
+  onCommand = (frame, linkType) => this.onCommandFrame(frame, linkType);
+  onClose = () => this.fail(new Error(`rtc live ${this.tag}: session closed`));
+  constructor(opts) {
+    super();
+    this.opts = opts;
+  }
+  get tag() {
+    return `${this.opts.stationSn}#${this.opts.channel}`;
+  }
+  start() {
+    if (this.running)
+      return this;
+    const { session, seg, accountId } = this.opts;
+    this.running = true;
+    session.on("mediaData", this.onMedia);
+    session.on("commandData", this.onCommand);
+    session.on("close", this.onClose);
+    this.startSegment = seg.next();
+    const sent2 = session.sendCommand(buildPortalPacket({
+      commandId: PORTAL_CMD_SET_PAYLOAD,
+      channel: PORTAL_STATION_CHANNEL,
+      segment: this.startSegment,
+      isResponse: LIVE_STREAM_ID,
+      payload: {
+        account_id: accountId,
+        cmd: LIVE_START,
+        payload: {
+          ClientOS: "WEB",
+          entrytype: 0,
+          camera_type: 0,
+          key: "",
+          msg_id: 116,
+          audio_chn: -1,
+          streamtype: 2,
+          stitch_mode: 1,
+          chn_list: [{ index: 0, chn: this.opts.channel, sensor: 0, isUps: 0, isClicked: true }],
+          pip_cord: { x1: 0, y1: 0, x2: 0, y2: 0 },
+          station_video_type: 6,
+          play_id: 1
+        }
+      }
+    }));
+    if (!sent2) {
+      queueMicrotask(() => this.fail(new Error(`rtc live ${this.tag}: command channel not open`)));
+      return this;
+    }
+    this.keepalive = setInterval(() => {
+      if (!session.sendRaw(PORTAL_KEEPALIVE))
+        this.opts.logger?.warn?.(`[rtc] ${this.tag} keepalive not sent`);
+    }, PORTAL_KEEPALIVE_MS);
+    this.keepalive.unref?.();
+    this.opts.logger?.debug?.(`[rtc] ${this.tag} live start sent`);
+    return this;
+  }
+  stop() {
+    if (!this.running)
+      return;
+    this.teardown();
+    const { session, seg, accountId } = this.opts;
+    session.sendCommand(buildPortalPacket({
+      commandId: PORTAL_CMD_SET_PAYLOAD,
+      channel: PORTAL_STATION_CHANNEL,
+      segment: seg.next(),
+      isResponse: LIVE_STREAM_ID,
+      payload: { account_id: accountId, cmd: LIVE_STOP, payload: {} }
+    }));
+    this.emit("stop");
+  }
+  teardown() {
+    this.running = false;
+    if (this.keepalive)
+      clearInterval(this.keepalive);
+    this.keepalive = void 0;
+    const { session } = this.opts;
+    session.off("mediaData", this.onMedia);
+    session.off("commandData", this.onCommand);
+    session.off("close", this.onClose);
+  }
+  fail(err) {
+    if (!this.running)
+      return;
+    this.teardown();
+    this.emit("error", err);
+  }
+  /** The start's ACK: a non-zero result code ends the pull. */
+  onCommandFrame(frame, linkType) {
+    const p = parsePortalPacket(frame, linkType);
+    if (!p?.isResponse || p.segment !== this.startSegment || p.commandId !== PORTAL_CMD_SET_PAYLOAD)
+      return;
+    if (p.errCode !== 0)
+      this.fail(new Error(`rtc live ${this.tag}: start refused (err ${p.errCode})`));
+  }
+  onMediaFrame(frame) {
+    const h = parsePortalHeader(frame);
+    if (!h || h.commandId !== LIVE_MEDIA || h.channel !== LIVE_MEDIA_CHANNEL)
+      return;
+    if (h.paramLength > frame.length - PORTAL_HEADER_LENGTH)
+      return;
+    const media = parseMediaBody(frame.subarray(PORTAL_HEADER_LENGTH, PORTAL_HEADER_LENGTH + h.paramLength));
+    if (!media)
+      return;
+    const { data, width, height } = media;
+    if (width && height) {
+      this.width = width;
+      this.height = height;
+    }
+    const out = {
+      codec: "h265",
+      data,
+      keyframe: hasIdr(data, "h265"),
+      width: this.width,
+      height: this.height
+    };
+    this.emit("video", out);
+  }
+};
+
+// dist/transport/rtc/session.js
+import { EventEmitter as EventEmitter10 } from "node:events";
+
+// dist/transport/rtc/peer.js
+import { EventEmitter as EventEmitter8 } from "node:events";
+
+// dist/transport/rtc/ptcs-framer.js
+var MAGIC3 = Buffer.from("PTCS", "ascii");
+var PTCS_HEADER_LENGTH = 28;
+var PTCS_DEFAULT_PAYLOAD_BYTES = 1e3;
+var FLAG_BASE = 16384;
+var FLAG_LAST = 1024;
+var LENGTH_MASK = 1023;
+var PtcsChannel = {
+  COMMAND: 0,
+  NOTIFY: 2,
+  LIVE: 5
+};
+function linkTypeForChannel(channel) {
+  if (channel === PtcsChannel.NOTIFY)
+    return PortalLinkType.NOTIFY;
+  if (channel === PtcsChannel.LIVE)
+    return PortalLinkType.LIVE;
+  return PortalLinkType.COMMAND;
+}
+var PTCS_STALE_MS = 15e3;
+function parsePtcsHeader(packet) {
+  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) could not load '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 EventEmitter8 {
+  opts;
+  pc;
+  channels = /* @__PURE__ */ new Map();
+  framer;
+  wireTally = /* @__PURE__ */ new Map();
+  commandOpen = false;
+  remoteSet = false;
+  remoteMid = HUB_SDP_MID;
+  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: this.opts.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 application = offer.split(/(?=^m=)/m).find((section) => section.startsWith("m=application "));
+      this.remoteMid = application?.match(/^a=mid:([^\r\n]+)/m)?.[1] ?? HUB_SDP_MID;
+      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 bytes on the command channel as they are, without PTCS framing; false when it isn't open. The
+   * portal's data-channel keepalive rides the wire unframed.
+   */
+  sendRaw(bytes2) {
+    const dc = this.channels.get(COMMAND_CHANNEL);
+    if (!dc?.isOpen())
+      return false;
+    return dc.sendMessageBinary(bytes2);
+  }
+  /**
+   * Send one portal packet on the command channel, through the framer. False when the channel is not
+   * usable or the native send refused a wire packet, so a dropped frame does not read as success.
+   */
+  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 this.opts.iceTransportPolicy === "all" || 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. The hub's echo of the portal
+   * keepalive on the command channel is unframed and surfaces as `keepaliveEcho` instead.
+   */
+  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")}`);
+      }
+      if (label === COMMAND_CHANNEL && buf.equals(PORTAL_KEEPALIVE)) {
+        this.emit("keepaliveEcho");
+        return;
+      }
+      this.framer?.recvPacket(buf);
+    });
+  }
+  addNow(candidate) {
+    try {
+      this.pc?.addRemoteCandidate(candidate, this.remoteMid);
+    } 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 EventEmitter9 } from "node:events";
+import { createHmac as createHmac3, randomUUID as randomUUID2 } from "node:crypto";
+var RTC_WS_PATH = "/v1/rtc/ws/join?reqtype=nvr";
+var RTC_SIGN_PATH = "/v1/smart/nvr/ws/sign";
+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 EventEmitter9 {
+  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 ?? "?"} ${withoutTokenEcho(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(this.opts.signalingMode ?? "scall");
+  }
+  sendAck() {
+    this.sendSession("ack");
+  }
+  /** The SDP answer, encoded for the negotiated call format, in an `info`. */
+  sendInfoSdp(sdp) {
+    this.sendSession("info", { sdp });
+  }
+  /** 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 EventEmitter10 {
+  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.trickle(toWireCandidate(c)));
+    this.peer.on("iceGatheringComplete", () => this.trickle(""));
+    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("keepaliveEcho", () => this.emit("keepaliveEcho"));
+    this.peer.on("data", (frame, linkType) => {
+      if (linkType === PortalLinkType.LIVE)
+        this.emit("mediaData", frame);
+      else
+        this.emit("commandData", frame, linkType);
+    });
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  /**
+   * Start the sequence; resolves once the call 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 ${this.opts.signalingMode ?? "scall"}`);
+    this.signaling.sendCall();
+  }
+  /** Send one portal packet; false when the command channel isn't open. */
+  sendCommand(portalPacket) {
+    return this.peer.sendCommand(portalPacket);
+  }
+  /** Send unframed bytes on the command channel; false when it isn't open. */
+  sendRaw(bytes2) {
+    return this.peer.sendRaw(bytes2);
+  }
+  /**
+   * Hang up and tear both sides down; `close` fires once, here if nothing announced it before. A
+   * `connect()` still waiting for the signalling auth is rejected and its timer stopped.
+   */
+  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();
+  }
+  /**
+   * Trickle one local candidate, or the empty end-of-candidates. The native peer can report one after the
+   * signalling socket has closed, and sending then throws inside a native callback, where the throw can't
+   * be caught and aborts the process. A candidate with no open socket is dropped.
+   */
+  trickle(candidate) {
+    if (!this.signaling.isOpen)
+      return;
+    this.signaling.sendInfoCandidate(candidate);
+  }
+  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(this.opts.signalingMode === "call" ? answer : 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_CONTROL_PAYLOAD = 1700;
+var PORTAL_CMD_NOTIFY_PAYLOAD = 1351;
+var ACK_TIMEOUT_MS = 8e3;
+var CONNECT_TIMEOUT_MS2 = 12e3;
+var IDLE_CLOSE_MS = 6e4;
+var StationStreamBusyError = class extends Error {
+  constructor(stationSn, servingSn) {
+    super(`rtc live: ${stationSn} is serving ${servingSn}; the station streams one camera at a time`);
+    this.name = "StationStreamBusyError";
+  }
+};
+var RtcCommandRouter = class {
+  deps;
+  sessions = /* @__PURE__ */ new Map();
+  lives = /* @__PURE__ */ new Map();
+  warm = /* @__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 RTC 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(route, 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;
+  }
+  /**
+   * The media of a camera on a T9000: live video, a readable feed and a live still over the station's
+   * session. Recording has no wire here and is refused; the optional members it has no wire for are absent.
+   */
+  mediaProviderFor(route) {
+    return {
+      live: (opts) => this.withLiveSource(route, opts ?? {}, (source) => attachUnlessAborted(source, opts?.signal)),
+      openReadable: (opts) => this.withLiveSource(route, opts ?? {}, (source) => openReadableFromConsumer(attachUnlessAborted(source, opts?.signal), opts)),
+      snapshotLive: (opts) => this.withLiveSource(route, opts ?? {}, (source) => captureSnapshotFromShared(source, { ...opts, logger: this.deps.logger, ffmpegPath: this.deps.ffmpegPath })).catch((e) => {
+        if (!(e instanceof StationStreamBusyError))
+          throw e;
+        throw new LiveSnapshotUnavailableError("source-failed", e.message, { cause: e });
+      }),
+      record: async () => {
+        throw new Error(`record is not available for ${route.cameraSn} over the T9000 control channel`);
+      }
+    };
+  }
+  /**
+   * Tear down every station session (logout / shutdown). Each live source is disposed before its session
+   * closes, so its consumers end cleanly and its stop still rides the session.
+   */
+  close() {
+    for (const [sn, live] of this.lives) {
+      this.lives.delete(sn);
+      live.source.dispose();
+    }
+    for (const [sn, st] of this.sessions)
+      this.drop(sn, st);
+  }
+  /**
+   * Hand `use` the station's live source for this camera, in the same turn the source is created or reused,
+   * so a consumer it attaches is counted before any other caller looks.
+   *
+   * The station streams one camera at a time. Another camera whose source has consumers refuses this one,
+   * before the session is awaited and again after; one with none (never attached or lingering)
+   * holds nothing a viewer needs, so it is disposed and the slot taken. The first caller's
+   * {@link SharedSourceHints} configure a new source.
+   */
+  async withLiveSource(route, opts, use) {
+    opts.signal?.throwIfAborted();
+    this.refuseIfWatched(route);
+    const identity = this.deps.identity();
+    if (!identity)
+      throw new Error(`rtc: not logged in, cannot open ${route.stationSn}`);
+    const accountId = route.adminUserId || identity.userId;
+    const st = await abortable(this.stationSession(route, accountId, identity), opts.signal);
+    this.refuseIfWatched(route);
+    const current = this.lives.get(route.stationSn);
+    if (current && current.cameraSn !== route.cameraSn) {
+      this.deps.logger?.debug?.(`[rtc] ${route.stationSn} releasing the unwatched source of ${current.cameraSn} for ${route.cameraSn}`);
+      this.lives.delete(route.stationSn);
+      current.source.dispose();
+    }
+    let live = this.lives.get(route.stationSn);
+    if (!live) {
+      live = { cameraSn: route.cameraSn, source: this.newLiveSource(route, st, accountId, opts) };
+      this.lives.set(route.stationSn, live);
+    }
+    return await use(live.source);
+  }
+  /** Refuse a camera while another camera on its station has consumers. */
+  refuseIfWatched(route) {
+    const current = this.lives.get(route.stationSn);
+    if (current && current.cameraSn !== route.cameraSn && current.source.consumerCount > 0) {
+      throw new StationStreamBusyError(route.stationSn, current.cameraSn);
+    }
+  }
+  newLiveSource(route, st, accountId, hints) {
+    let leased = false;
+    const release = () => {
+      if (!leased)
+        return;
+      leased = false;
+      st.leases = Math.max(0, st.leases - 1);
+      this.touch(route.stationSn, st);
+    };
+    const source = new SharedLiveSource({
+      makeStream: () => new RtcLiveStream({
+        session: st.session,
+        seg: st.seg,
+        stationSn: route.stationSn,
+        channel: route.channel,
+        accountId,
+        logger: this.deps.logger
+      }),
+      label: `${route.stationSn}#${route.channel}`,
+      logger: this.deps.logger,
+      powered: hints.powered,
+      preBufferSeconds: hints.preBufferSeconds,
+      onActive: () => {
+        if (leased)
+          return;
+        leased = true;
+        st.leases++;
+        if (st.idle)
+          clearTimeout(st.idle);
+      },
+      onStopped: () => {
+        release();
+        if (this.lives.get(route.stationSn)?.source === source)
+          this.lives.delete(route.stationSn);
+      }
+    });
+    return source;
+  }
+  /**
+   * Completes on the command ACK or a correlated control-result notification. The notification must
+   * match the request channel, parameter and segment and contain a structured payload. Receipt does
+   * 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(route, adminUserId, identity) {
+    const sn = route.stationSn;
+    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,
+      signalingMode: route.signalingMode,
+      peer: { logger: this.deps.logger, iceTransportPolicy: route.iceTransportPolicy }
+    });
+    const ready = this.bringUp(sn, session);
+    const st = { session, seg: new SegmentCounter(), ready, queue: Promise.resolve(), leases: 0 };
+    session.on("error", (e) => this.deps.onError?.(e));
+    session.on("close", () => {
+      if (this.sessions.get(sn) === st)
+        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))));
+    });
+  }
+  /**
+   * Hold a station's command session open: one hold per station, its idle-close ({@link IDLE_CLOSE_MS})
+   * suppressed, {@link PORTAL_KEEPALIVE} sent every {@link PORTAL_KEEPALIVE_MS}, and the session dropped
+   * on a tick that finds the previous keepalive unechoed. A closed session ends the hold.
+   *
+   * Answers an idempotent disposer that releases the hold. Throws when no account is logged in.
+   */
+  keepWarm(route) {
+    const sn = route.stationSn;
+    const existing = this.warm.get(sn);
+    if (existing)
+      return existing.dispose;
+    const identity = this.deps.identity();
+    if (!identity)
+      throw new Error(`rtc: not logged in, cannot warm ${sn}`);
+    const hold = {
+      awaitingEcho: false,
+      dispose: () => {
+        if (this.warm.get(sn) !== hold)
+          return;
+        this.warm.delete(sn);
+        const st = hold.watch?.st;
+        this.unwatch(hold);
+        if (st) {
+          st.leases = Math.max(0, st.leases - 1);
+          this.touch(sn, st);
+        }
+      }
+    };
+    this.warm.set(sn, hold);
+    void this.warmUp(sn, route, identity, hold);
+    return hold.dispose;
+  }
+  /**
+   * Bring a station session up for a {@link keepWarm} hold and start its keepalive. A bring-up that fails,
+   * or a hold disposed before it completes, clears the hold and arms no timer. Each tick first checks
+   * that the hub echoed the previous keepalive, and drops the session when it did not. The keepalive
+   * stops when the session closes, which also clears the hold so the next command or `keepWarm`
+   * rebuilds cleanly.
+   */
+  async warmUp(sn, route, identity, hold) {
+    const adminUserId = route.adminUserId || identity.userId;
+    let st;
+    try {
+      st = await this.stationSession(route, adminUserId, identity);
+    } catch (e) {
+      if (this.warm.get(sn) === hold)
+        this.warm.delete(sn);
+      this.deps.onError?.(e instanceof Error ? e : new Error(String(e)));
+      return;
+    }
+    if (this.warm.get(sn) !== hold) {
+      this.touch(sn, st);
+      return;
+    }
+    st.leases++;
+    this.touch(sn, st);
+    const onClose = () => {
+      this.unwatch(hold);
+      if (this.warm.get(sn) === hold)
+        this.warm.delete(sn);
+    };
+    const onEcho = () => {
+      hold.awaitingEcho = false;
+    };
+    hold.watch = { st, onClose, onEcho };
+    st.session.once("close", onClose);
+    st.session.on("keepaliveEcho", onEcho);
+    hold.keepalive = setInterval(() => {
+      if (hold.awaitingEcho) {
+        this.deps.logger?.warn?.(`[rtc] ${sn} warm keepalive went unechoed, dropping the session`);
+        this.drop(sn, st);
+        return;
+      }
+      hold.awaitingEcho = true;
+      st.session.sendRaw(PORTAL_KEEPALIVE);
+    }, PORTAL_KEEPALIVE_MS);
+    hold.keepalive.unref?.();
+  }
+  /** Stop a hold's keepalive and remove its listeners from the session it watches. */
+  unwatch(hold) {
+    if (hold.keepalive)
+      clearInterval(hold.keepalive);
+    hold.keepalive = void 0;
+    if (hold.watch) {
+      hold.watch.st.session.off("close", hold.watch.onClose);
+      hold.watch.st.session.off("keepaliveEcho", hold.watch.onEcho);
+    }
+    hold.watch = void 0;
+  }
+  touch(sn, st) {
+    if (st.idle)
+      clearTimeout(st.idle);
+    if (st.leases > 0)
+      return;
+    st.idle = setTimeout(() => this.drop(sn, st), IDLE_CLOSE_MS);
+    st.idle.unref?.();
+  }
+  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";
+
+// dist/transport/mqtt/broker-discovery.js
+import { resolve4 } from "node:dns/promises";
+async function resolveBrokerIps(hostname) {
+  try {
+    return await resolve4(hostname);
+  } catch {
+    return [];
+  }
+}
+function mergeCandidateIps(dnsIps, extraIps = []) {
+  return Array.from(/* @__PURE__ */ new Set([...dnsIps, ...extraIps]));
+}
+function rankResults(results) {
+  return [...results].sort((a, b) => Number(b.granted) - Number(a.granted));
+}
+async function probeBrokerInstance(ip, creds, opts) {
+  const mqtt = await loadMqtt();
+  const start = Date.now();
+  const timeoutMs = opts.timeoutMs ?? 8e3;
+  return await new Promise((resolvePromise) => {
+    let settled = false;
+    const finish = (r) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        client.end(true);
+      } catch {
+      }
+      resolvePromise({ ip, ms: Date.now() - start, ...r });
+    };
+    const client = mqtt.connect({
+      host: ip,
+      port: creds.port ?? 8883,
+      protocol: "mqtts",
+      ...bareIpTlsOptions({
+        hostname: creds.hostname,
+        cert: creds.certificate_pem,
+        key: creds.private_key,
+        ca: creds.aws_root_ca1_pem
+      }),
+      clientId: opts.clientId,
+      protocolVersion: 4,
+      keepalive: 60,
+      clean: true,
+      reconnectPeriod: 0,
+      connectTimeout: timeoutMs
+    });
+    const timer = setTimeout(() => finish({ granted: false, error: "timeout" }), timeoutMs);
+    client.on("connect", () => {
+      client.subscribe(opts.topic, { qos: 1 }, (err, granted, packet) => {
+        if (err) {
+          const code = packet?.granted?.[0];
+          return finish({
+            granted: false,
+            grantedQos: typeof code === "number" ? code : void 0,
+            error: err.message
+          });
+        }
+        const g = granted?.[0];
+        finish({ granted: !!g, grantedQos: g?.qos });
+      });
+    });
+    client.on("error", (err) => finish({ granted: false, error: err.message }));
+  });
+}
+async function discoverReachableInstance(creds, opts) {
+  const dnsIps = await resolveBrokerIps(creds.hostname);
+  const all = mergeCandidateIps(dnsIps, opts.candidateIps);
+  const results = [];
+  for (const ip of all) {
+    const r = await probeBrokerInstance(ip, creds, {
+      clientId: opts.clientIdFor(ip),
+      topic: opts.topic,
+      timeoutMs: opts.perAttemptTimeoutMs
+    });
+    results.push(r);
+    if (r.granted && opts.stopOnFirstGrant)
+      break;
+  }
+  return rankResults(results);
 }
 
 // dist/transport/dp-preset.js
@@ -22660,10 +24670,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,
@@ -22842,8 +24852,9 @@ var MqttCommandRouter = class _MqttCommandRouter {
    * One exception is known: a single garage unit whose own-cert SUBSCRIBE was denied on every candidate
    * while a phone-extracted cert granted on the same one, with a sibling of the same model on the same
    * account granting fine. That is a per-device authorization gap on the vendor's backend, not a
-   * broker-instance problem and not something this SDK works around — such a device reports as offline
-   * (the throw below) until the backend grants the account's own credentials.
+   * broker-instance problem and not something this SDK works around — the throw below names each
+   * candidate's outcome (its SUBACK deny code, a timeout or a connection error) until the backend grants
+   * the account's own credentials.
    *
    * One fresh, explicitly non-reconnecting (`reconnectPeriod: 0`) connection per call — it repays the
    * full mTLS handshake every command and tears the socket down right after (see
@@ -22872,7 +24883,7 @@ var MqttCommandRouter = class _MqttCommandRouter {
     });
     const winner = results.find((res) => res.granted);
     if (!winner) {
-      throw new Error(`ensureSecurityMqttFor(${dev.sn}): no broker instance currently holds this device's session (probed ${results.length} candidate IPs, all denied/unreachable) \u2014 the device may be offline.`);
+      throw new Error(`ensureSecurityMqttFor(${dev.sn}): no broker instance currently holds this device's session (probed ${results.length} candidate IPs: ` + results.map((r) => `${r.ip} ${r.grantedQos === void 0 ? "" : `SUBACK 0x${r.grantedQos.toString(16)} `}${r.error ?? "denied"}`).join("; ") + `).`);
     }
     const m = new SecureMqtt({
       credentials: creds,
@@ -23350,7 +25361,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 +25404,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 +25413,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 +25445,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 +25982,7 @@ async function resolveLightEffect(mega, lightId) {
 }
 
 // dist/transport/push/push-client.js
-import { EventEmitter as EventEmitter8 } from "node:events";
+import { EventEmitter as EventEmitter12 } from "node:events";
 import tls2 from "node:tls";
 
 // dist/transport/push/proto.js
@@ -24226,7 +26237,7 @@ var MessageTag;
 })(MessageTag || (MessageTag = {}));
 
 // dist/transport/push/parser.js
-import { EventEmitter as EventEmitter7 } from "node:events";
+import { EventEmitter as EventEmitter11 } from "node:events";
 var State;
 (function(State2) {
   State2[State2["VERSION_TAG_AND_SIZE"] = 0] = "VERSION_TAG_AND_SIZE";
@@ -24244,7 +26255,7 @@ var TAG_TO_TYPE = {
   [MessageTag.DataMessageStanza]: "mcs_proto.DataMessageStanza",
   [MessageTag.StreamErrorStanza]: "mcs_proto.StreamErrorStanza"
 };
-var McsParser = class extends EventEmitter7 {
+var McsParser = class extends EventEmitter11 {
   data = Buffer.alloc(0);
   state = State.VERSION_TAG_AND_SIZE;
   messageTag = 0;
@@ -24422,7 +26433,7 @@ function normalizePushEvent(raw) {
     raw
   };
 }
-var PushClient = class _PushClient extends EventEmitter8 {
+var PushClient = class _PushClient extends EventEmitter12 {
   creds;
   logger;
   /** Consecutive MCS login rejections tolerated (self-healing propagation) before surfacing an error. */
@@ -25012,7 +27023,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 +27055,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,21 +27151,24 @@ 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),
+          ...typeof raw.device_channel === "number" ? { channel: raw.device_channel } : {},
           p2pDid: raw.p2p_did,
           params,
           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 +27259,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 +27327,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 {
@@ -25560,6 +27620,8 @@ function tuyaDevIdFrom(raw) {
 var DEFAULT_POLL_MS = 6e5;
 var DEFAULT_PREWARM_TIERS = ["wired", "battery"];
 var SESSION_RECYCLE_WAIT_MS = 5e3;
+var PUSH_RETRY_MIN_MS = 3e4;
+var PUSH_RETRY_MAX_MS = 6e5;
 var RealtimeStartupSupersededError = class extends Error {
 };
 var RefreshWindowClosedError = class extends Error {
@@ -25575,7 +27637,7 @@ function readinessSnapshot(readiness, state = readiness.state) {
     wiredP2p: Object.freeze({ ...readiness.wiredP2p })
   });
 }
-var EufyMega = class extends EventEmitter9 {
+var EufyMega = class extends EventEmitter13 {
   opts;
   mega;
   /**
@@ -25635,6 +27697,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). */
@@ -25656,6 +27720,8 @@ var EufyMega = class extends EventEmitter9 {
   mapStores = /* @__PURE__ */ new Map();
   /** Re-armed after each cloud-param poll; cancelled by {@link disconnect}. */
   pollTimer = new Timer();
+  /** Armed while a failed push bring-up waits to be retried; cancelled by {@link disconnect}. */
+  pushRetryTimer = new Timer();
   constructor(opts) {
     super();
     this.opts = opts;
@@ -25695,6 +27761,14 @@ 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,
+      ffmpegPath: opts.ffmpegPath,
+      onError: (e) => this.reportError(e)
+    });
     this.mqtt = new MqttCommandRouter({
       mega: this.mega,
       logger: opts.logger,
@@ -25960,13 +28034,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 +28109,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 +28161,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,
@@ -26121,10 +28208,24 @@ var EufyMega = class extends EventEmitter9 {
   recycleStandaloneSession(sn) {
     const releaseWrite = new Promise((resolve) => void setTimeout(resolve, SESSION_RECYCLE_WAIT_MS).unref?.());
     return Promise.race([
-      this.p2p.resetStandaloneSession(sn),
+      this.p2p.resetStandaloneSession(sn).finally(() => this.reopenWiredStation(sn)),
       releaseWrite.then(() => this.opts.logger?.debug(`[session ${sn}] recycle still waiting on an attached viewer \u2014 releasing the write that asked for it`))
     ]);
   }
+  /** Reopen a wired station that {@link recycleStandaloneSession} closed, while the generation that warmed it is current. */
+  reopenWiredStation(sn) {
+    const generation = this.realtimeGeneration;
+    if (generation?.epoch !== this.realtimeEpoch)
+      return;
+    if (this.p2p.stationKeyOf(sn) !== sn || !this.registry.p2pDevices().some((d) => d.sn === sn))
+      return;
+    if (this.stationPower(sn) !== "wired")
+      return;
+    void this.p2p.ensureStation(sn, generation.abort.signal).catch((error) => {
+      if (!generation.abort.signal.aborted)
+        this.reportError(error);
+    });
+  }
   /**
    * Whether the DECODED property now reads what the write asked for.
    *
@@ -26381,6 +28482,28 @@ var EufyMega = class extends EventEmitter9 {
       }
     };
   }
+  /**
+   * The station a device's commands go through: the device itself, or the HomeBase the registry links it
+   * to. Answers the target record, the station record and serial, the station's `device_type`, and the
+   * `t9000` / `t8n00` family flags.
+   */
+  stationOf(sn) {
+    const devices = this.registry.list();
+    const target = devices.find((d) => d.sn === sn);
+    const stationSn = target?.stationSn || sn;
+    const station = devices.find((d) => d.sn === stationSn);
+    const raw = station?.raw ?? {};
+    const deviceType = typeof raw.device_type === "number" ? raw.device_type : void 0;
+    const family = { deviceType, model: station?.model };
+    return { target, station, stationSn, raw, deviceType, t9000: isStation9000(family), t8n00: isNvrT8N00(family) };
+  }
+  /** The vendor DeviceType of the station a device hangs off; `undefined` for a station itself. */
+  stationDeviceTypeOf(sn) {
+    const st = this.stationOf(sn);
+    if (!st.station || st.stationSn === sn)
+      return void 0;
+    return st.deviceType;
+  }
   /**
    * Combine explicit P2P media with the optional passive push-thumbnail provider.
    *
@@ -26391,7 +28514,7 @@ var EufyMega = class extends EventEmitter9 {
    * current. With nothing retained the refusal stands.
    */
   mediaProviderFor(sn) {
-    const media = this.p2p.mediaProviderFor(sn);
+    const media = this.rtcMediaFor(sn) ?? this.p2p.mediaProviderFor(sn);
     const cache = this.storedImages;
     if (!cache)
       return media;
@@ -26428,8 +28551,10 @@ 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 or T8N00
+   * 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. T8N00 uses full SDP and admits direct and
+   * relay candidates; T9000 retains compact SDP and relay-only candidates. Everything else is P2P.
    */
   routeCommand(sn, cmd) {
     if (cmd.kind === "ff09-actuate" || cmd.kind === "ff09-autolock" || cmd.kind === "ff09-setting-toggle") {
@@ -26449,8 +28574,42 @@ var EufyMega = class extends EventEmitter9 {
         return this.tuya.dispatchCommand(sn, cmd);
       return this.mqtt.dispatchCommand(sn, cmd);
     }
+    const route = this.rtcRouteFor(sn);
+    if (route) {
+      if (route.attached && this.registry.serialForFrame(route.stationSn, cmd.channel) !== sn)
+        return Promise.reject(new Error("RTC command requires an unambiguous attached-device channel"));
+      return this.rtc.dispatchCommand(route, cmd);
+    }
     return this.p2p.dispatchCommand(sn, cmd);
   }
+  /**
+   * The RTC route for a T9000 or T8N00 station or a device attached to one, decided by the station's model
+   * classification; `undefined` for any other device. A T8N00 route carries its native `call` signalling. The admin id is the station's
+   * `member.admin_user_id`, else the logged-in user.
+   */
+  rtcRouteFor(sn) {
+    const { target, station, stationSn, raw, t9000, t8n00: native } = this.stationOf(sn);
+    if (!target || !station || !(t9000 || native))
+      return void 0;
+    const member = raw.member?.admin_user_id;
+    const adminUserId = typeof member === "string" && member ? member : void 0;
+    const base = { stationSn, adminUserId, attached: stationSn !== sn };
+    return native ? { ...base, signalingMode: "call", iceTransportPolicy: "all" } : base;
+  }
+  /**
+   * The RTC media provider for a camera attached to a T9000 whose `device_channel` resolves back to it on
+   * the station; `undefined` otherwise, including a camera behind a T8N00, whose route carries commands only.
+   */
+  rtcMediaFor(sn) {
+    const route = this.rtcRouteFor(sn);
+    if (!route?.attached || route.signalingMode === "call")
+      return void 0;
+    const raw = this.registry.list().find((d) => d.sn === sn)?.raw ?? {};
+    const channel = typeof raw.device_channel === "number" ? raw.device_channel : void 0;
+    if (channel === void 0 || this.registry.serialForFrame(route.stationSn, channel) !== sn)
+      return void 0;
+    return this.rtc.mediaProviderFor({ ...route, cameraSn: sn, channel });
+  }
   /**
    * List + classify devices across all houses (mega API). Each device is tagged with its API backend
    * + realtime transport. Camera/HomeBase records still appear here for inventory; driving them is
@@ -26683,13 +28842,38 @@ var EufyMega = class extends EventEmitter9 {
       this.schedulePoll();
       const failures = readiness.push.failed + readiness.mqtt.failed + readiness.wiredP2p.failed;
       this.settleRealtimeGeneration(generation, failures || startupFailed ? "partial" : "ready");
+      if (readiness.push.failed)
+        this.retryPush(generation);
     } catch (e) {
       this.reportError(e);
       readiness.push.failed += readiness.push.pending;
       readiness.push.pending = 0;
       this.settleRealtimeGeneration(generation, epoch === this.realtimeEpoch ? "partial" : "superseded");
+      if (epoch === this.realtimeEpoch)
+        this.retryPush(generation);
     }
   }
+  /**
+   * Bring push up again after the generation's startup attempt failed, backing off between attempts
+   * until one connects, the generation is superseded, or it is aborted by {@link disconnect}.
+   *
+   * The MCS socket reconnects on its own only once it has connected. The settled
+   * {@link RealtimeReadiness} is a startup snapshot and is not revised when a retry connects.
+   */
+  retryPush(generation, delayMs = PUSH_RETRY_MIN_MS) {
+    this.pushRetryTimer.arm(delayMs, () => {
+      this.startPush(generation.abort.signal).then((client) => {
+        if (generation.epoch !== this.realtimeEpoch)
+          return client.close();
+        this.pushClient = client;
+      }, (error) => {
+        if (generation.epoch !== this.realtimeEpoch)
+          return;
+        this.reportError(error);
+        this.retryPush(generation, Math.min(delayMs * 2, PUSH_RETRY_MAX_MS));
+      });
+    });
+  }
   /** Resolve a generation with an immutable count snapshot; later transport completions are ignored. */
   settleRealtimeGeneration(generation, state) {
     if (generation.settled)
@@ -26918,6 +29102,17 @@ var EufyMega = class extends EventEmitter9 {
       await this.getDevices();
     await this.p2p.ensureStation(this.p2p.stationKeyOf(deviceSn), signal);
   }
+  /**
+   * Keep a T9000 station's RTC command session open and warm, so a command fires without a cold reconnect.
+   * Answers the hold's disposer; throws for any other station, and while logged out.
+   */
+  keepStationWarm(stationSn) {
+    const { t9000 } = this.stationOf(stationSn);
+    const route = this.rtcRouteFor(stationSn);
+    if (!t9000 || !route)
+      throw new Error(`rtc: ${stationSn} has no warm command session`);
+    return this.rtc.keepWarm(route);
+  }
   /** Eagerly open P2P sessions for WIRED stations only (persistent — they don't drain). Battery
    *  stations stay closed until an on-demand open. Best-effort per station. */
   async warmWiredP2P(readiness = createPlaneReadiness(), signal) {
@@ -27287,16 +29482,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 +29527,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;
@@ -27366,6 +29566,7 @@ var EufyMega = class extends EventEmitter9 {
       hasP2p: P2PCommandRouter.claimsDevice(dev),
       // Topology as the record states it: a parent that isn't the device itself means HomeBase-attached.
       homeBaseAttached: !!raw.parent_sn && raw.parent_sn !== dev.sn,
+      stationDeviceType: this.stationDeviceTypeOf(sn),
       dpCatalog
     };
   }
@@ -27540,8 +29741,10 @@ var EufyMega = class extends EventEmitter9 {
    */
   async teardownRealtime() {
     this.pollTimer.cancel();
+    this.pushRetryTimer.cancel();
     this.lastStateAnnounced.clear();
     await this.closeMqttTransports();
+    this.rtc.close();
     await this.p2p.closeAll();
     this.pushClient?.close();
     this.pushClient = void 0;
@@ -28046,7 +30249,7 @@ var SolixClient = class _SolixClient {
 };
 
 // dist/transport/mqtt/solix-mqtt.js
-import { EventEmitter as EventEmitter10 } from "node:events";
+import { EventEmitter as EventEmitter14 } from "node:events";
 var SOLIX_METER_FIELD_NAMES = {
   168: "meterPowerL1",
   // Anker Modbus: primary_phase_1_active_power
@@ -28224,7 +30427,7 @@ function addSolarbankScalars(frame, out) {
     out.gridExportLimit = df.readUInt16LE(5);
   }
 }
-var SolixMqtt = class extends EventEmitter10 {
+var SolixMqtt = class extends EventEmitter14 {
   transport;
   appName;
   userId;