@mega-yfue/eufy-sdk 0.5.0-beta.13 → 0.5.0-beta.15

package/dist/client/device-registry.d.ts

@@ -92,6 +92,8 @@ export declare class DeviceRegistry {
     private overlayRefusalReported;
     /** Per-serial capability cache for {@link capabilitiesForDevice}; `null` = negative hit. */
     private readonly deviceCapsCache;
+    /** Per-serial cloud data points of an AIoT robot, joined beneath the params in {@link record} — see {@link loadCloudDps}. */
+    private readonly cloudDps;
     /** Per-serial realtime state, keyed by param id in the device's own namespace (see {@link DeviceRecord.dpParams}). */
     private readonly dpParams;
     /** Callers blocked in {@link awaitRealtimeState}, released by the device's first report. */
@@ -181,9 +183,26 @@ export declare class DeviceRegistry {
      * transport stacks own the claim predicate over the record.
      */
     require(sn: string): EufyDevice;
+    /**
+     * 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.
+     */
+    private loadCloudDps;
     /**
      * 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

package/dist/core/contracts.d.ts

@@ -551,16 +551,25 @@ export type AudioCodec = "aac-lc" | "aac-eld" | "g711a";
 /**
  * One audio access unit, carrying the codec the station declared for it.
  *
- * Sample rate and channel count are deliberately absent: they are not on the wire. The v6 app assumes
- * 16 kHz mono for every audio type rather than reading them, so the SDK does not invent fields the
- * device never sent.
+ * Sample rate and channel count are absent for `aac-lc` and `g711a`: they are not on the wire, and the v6 app
+ * assumes 16 kHz mono for every audio type rather than reading them. An `aac-lc` frame is one ADTS frame and
+ * `g711a` is raw A-law. An `aac-eld` frame is one raw access unit with no transport framing, so it carries the
+ * AudioSpecificConfig that decodes it.
  */
-export interface LiveAudioFrame {
+export type LiveAudioFrame = {
     /** Codec declared in the frame header. */
-    codec: AudioCodec;
-    /** Elementary-stream bytes (ADTS-framed for the two AAC profiles). */
+    codec: "aac-lc" | "g711a";
+    /** One ADTS frame for `aac-lc`, raw A-law samples for `g711a`. */
     data: Buffer;
-}
+    config?: undefined;
+} | {
+    /** Codec declared in the frame header. */
+    codec: "aac-eld";
+    /** One raw AAC-ELD access unit. */
+    data: Buffer;
+    /** AudioSpecificConfig (ISO/IEC 14496-3) that decodes `data`. */
+    config: Buffer;
+};
 /**
  * One fragmented-MP4 (CMAF) output unit from the native muxer. `init` (the `ftyp`+`moov` init
  * segment) is present exactly once, on the first fragment; every fragment carries a `moof`+`mdat`

package/dist/index.js

@@ -1996,6 +1996,17 @@ ${this.auth_?.authToken ?? ""}`;
       device_sns: [deviceSn]
     });
   }
+  /**
+   * Fetch the account's devices as the `devicerelation` service lists them, `{attribute: 7, house_id: ""}`.
+   *
+   * Each entry is `{device: {device_sn, dps, …}}`, and `dps` is the cloud's last-known value of every
+   * data point that device has reported, keyed by DP number. Answered for an account a device is shared
+   * with as well as for its owner. Sent with `category: eufy_home`, without which the service answers
+   * `10000`.
+   */
+  getDeviceRelationList() {
+    return this.post("devicerelation", "/app/devicerelation/get_device_list", { attribute: 7, house_id: "" }, { category: "eufy_home" });
+  }
   /**
    * Fetch one page of a device's **cleaning history** from the mega `clean` service.
    *
@@ -17931,6 +17942,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;
@@ -18159,7 +18171,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 });
           }
         }
       }
@@ -20177,7 +20189,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 {
@@ -20195,6 +20207,8 @@ var Fmp4Muxer = class {
   lastVideoTimestampMs;
   audioRequested;
   audioCodec;
+  /** Decoder config of an AAC-ELD track, taken from its frames; absent for AAC-LC, whose `esds` config is fixed. */
+  audioConfig;
   audioDisabled = false;
   audioSamples = [];
   audioBaseDecodeTime = 0;
@@ -20261,7 +20275,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;
@@ -20277,12 +20294,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;
@@ -20294,7 +20318,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
     });
@@ -20567,7 +20591,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]));
@@ -26318,6 +26342,7 @@ function deviceClassOf(codec, realtime) {
   return cls === "camera" && realtime !== "p2p" ? "other" : cls;
 }
 var LIST_REUSE_MS = 5e3;
+var CLOUD_DPS_MODELS = /* @__PURE__ */ new Set(["T2351"]);
 var DeviceRegistry = class {
   mega;
   onError;
@@ -26342,6 +26367,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. */
@@ -26451,6 +26478,7 @@ var DeviceRegistry = class {
         });
       }
     }
+    await this.loadCloudDps(seen);
     this.lastRefreshPartial = partial;
     if (partial) {
       for (const prev of this.devices)
@@ -26541,9 +26569,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
@@ -26572,7 +26637,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 {