@mega-yfue/eufy-sdk 0.6.0-beta.35 → 0.6.0-beta.37

package/dist/core/contracts.d.ts

@@ -173,10 +173,10 @@ export declare class RecordingDownloadError extends Error {
  *
  * `video` is Annex-B H.264 or H.265 in decode order, `audio` AAC-LC 16 kHz mono in ADTS framing (absent
  * when the recording carried none that could be decoded). `codec` is the codec of `video`, read off the parameter
- * sets of its first keyframe that carries them, and is absent when no keyframe does. `frames` counts the distinct
- * video sequences emitted. `missingFrames` counts gaps between received sequences and received sequences that yielded no
- * usable picture, including at either end. `durationMs` spans the first to the last emitted picture by the
- * camera's own timestamps; `fps` is derived from those stamps.
+ * sets of its first keyframe that carries them, and is absent when no keyframe does. `frames` counts the pictures
+ * emitted, numbered by the camera's frame numbers counted on across a change of frame size. `missingFrames` counts
+ * gaps in that numbering and numbered frames that yielded no usable picture, including at either end. `durationMs`
+ * spans the first to the last emitted picture by the camera's own timestamps; `fps` is derived from those stamps.
  */
 export interface RecordingDownload {
     video: Buffer;

package/dist/index.js

@@ -20199,18 +20199,28 @@ function decodeRecording(frames, station, eccPrivateKeyHex) {
   const receivedNumbers = /* @__PURE__ */ new Set();
   let firstStamp;
   let lastStamp;
+  let frameSize;
+  let shift = 0;
+  let sequence = 0;
   for (const { commandId, raw } of frames) {
     if (commandId === CommandType.CMD_VIDEO_FRAME) {
       const header = parseVideoFrameHeader(raw);
       if (!header)
         continue;
-      receivedNumbers.add(header.sequence);
+      const size = header.width && header.height ? `${header.width}x${header.height}` : void 0;
+      if (header.keyframe && size && frameSize !== void 0 && size !== frameSize) {
+        shift = sequence + 1 - header.sequence & 65535;
+      }
+      if (size)
+        frameSize = size;
+      sequence = header.sequence + shift & 65535;
+      receivedNumbers.add(sequence);
       const units = assembler.push(raw, (payload) => decoder && header.keyframe ? decoder.decodeFrame(payload)?.h264 : clearVideoPayload(payload, header));
       for (const unit of units) {
         video.push(unit.data);
         if (unit.keyframe)
           codec ??= sniffAnnexbCodec(unit.data);
-        numbers.add(header.sequence);
+        numbers.add(sequence);
         const stamp = raw.readUIntLE(14, 6);
         firstStamp ??= stamp;
         lastStamp = stamp;
@@ -25545,13 +25555,14 @@ var RtcSession = class extends EventEmitter11 {
   closeAnnounced = false;
   sdpHandled = false;
   chain = Promise.resolve();
+  stageReached = "signing";
+  lastPeerState;
   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 });
-    const mediaTrack = opts.peer?.mediaTrack === true;
     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)));
@@ -25565,6 +25576,7 @@ var RtcSession = class extends EventEmitter11 {
       if (this.connected)
         return;
       this.connected = true;
+      this.stageReached = "connected";
       this.logger.debug(`[rtc] ${this.opts.stationSn} command channel open`);
       this.emit("connected");
     });
@@ -25576,9 +25588,14 @@ var RtcSession = class extends EventEmitter11 {
       this.announceClose();
     });
     this.peer.on("connectionState", (state) => {
-      if ((state === "failed" || state === "closed") && (this.connected || mediaTrack)) {
+      this.lastPeerState = state;
+      if (state !== "failed" && state !== "closed")
+        return;
+      if (this.connected || this.mediaTrack) {
         this.connected = false;
         this.announceClose();
+      } else {
+        this.shutdown(new Error(`RTC ${this.opts.stationSn} peer ${state} before the command channel opened`));
       }
     });
     this.peer.on("error", (e) => this.emit("error", e));
@@ -25591,9 +25608,20 @@ var RtcSession = class extends EventEmitter11 {
         this.emit("commandData", frame, linkType);
     });
   }
+  get mediaTrack() {
+    return this.opts.peer?.mediaTrack === true;
+  }
   get isConnected() {
     return this.connected;
   }
+  /** The last bring-up stage this session reached. */
+  get stage() {
+    return this.stageReached;
+  }
+  /** The peer connection's last reported state; `undefined` before it reports one. */
+  get peerState() {
+    return this.lastPeerState;
+  }
   /**
    * 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
@@ -25603,11 +25631,14 @@ var RtcSession = class extends EventEmitter11 {
     await this.signaling.fetchSign();
     if (this.closed)
       throw new Error("RTC session closed before the call was placed");
+    this.stageReached = "connecting";
     await this.signaling.connect();
+    this.stageReached = "authenticating";
     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.stageReached = "calling";
     this.signaling.sendCall();
   }
   /** Send one portal packet; false when the command channel isn't open. */
@@ -25703,6 +25734,9 @@ var RtcSession = class extends EventEmitter11 {
         return;
       case "hangup":
         this.logger.debug(`[rtc] ${this.opts.stationSn} hub hung up`);
+        if (!this.connected && this.opts.signalingMode !== "call") {
+          this.shutdown(new Error(`RTC ${this.opts.stationSn} hub hung up before the command channel opened`));
+        }
         return;
       default:
         return;
@@ -25715,6 +25749,7 @@ var RtcSession = class extends EventEmitter11 {
     const status = payload.status;
     if (status === 100 && payload.turn) {
       this.turn = payload.turn;
+      this.stageReached = "relay-granted";
       try {
         await this.peer.init(payload.turn);
       } catch (e) {
@@ -25770,6 +25805,7 @@ var RtcSession = class extends EventEmitter11 {
     }
     const answer = await this.peer.handleRemoteOffer(offer);
     this.signaling.sendInfoSdp(this.opts.signalingMode === "call" ? answer : JSON.stringify(sdpToScallJson(answer)));
+    this.stageReached = "answered";
     this.logger.debug(`[rtc] ${this.opts.stationSn} answered the hub's offer`);
   }
 };
@@ -26248,7 +26284,8 @@ var RtcCommandRouter = class {
   /**
    * 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 (rejecting
-   * with the failure that closed it, when it carries one), or {@link CONNECT_TIMEOUT_MS} passes. A single
+   * with the failure that closed it, when it carries one), or {@link CONNECT_TIMEOUT_MS} passes, naming the
+   * stage the session reached and its peer's last state. A single
    * promise, so an early failure cannot leave a second one rejecting unheard.
    */
   bringUp(sn, session) {
@@ -26274,7 +26311,7 @@ var RtcCommandRouter = class {
       };
       const onConnected = () => finish();
       const onClose = (err) => finish(err ?? 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);
+      const timer = setTimeout(() => finish(new Error(`rtc: ${sn} did not come up within ${CONNECT_TIMEOUT_MS2}ms (stage ${session.stage}, peer ${session.peerState ?? "not started"})`)), 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))));