@mega-yfue/eufy-sdk 0.5.0-beta.82 → 0.5.0-beta.83

package/dist/transport/p2p/command-router.d.ts

@@ -262,7 +262,7 @@ export declare class P2PCommandRouter {
      * A {@link MediaProvider} bound to one serial — resolves the session then calls `p2p/media`.
      *
      * Every live egress here is a consumer of the SAME shared pull, so N `live()` calls collapse to one
-     * PPCS session and a live snapshot against a warm, keyframe-primed source costs no extra pull at all; a
+     * PPCS session and a live snapshot against a warm shared source costs no extra pull at all; a
      * cold source warms one and waits for a clean keyframe. Each shared egress passes its complete options
      * through because any of them may create the source, whose power and retention hints are fixed for
      * everyone who joins later. The bounded {@link MediaProvider.record} clip is the exception: it opens its

package/dist/transport/p2p/media.d.ts

@@ -24,11 +24,9 @@ import type { SharedLiveSource } from "./shared-live-source.js";
 export declare function openLiveStream(session: P2PSession, opts?: LiveStreamOptions): Promise<LiveStream>;
 /**
  * **Live snapshot off a SHARED source** (V6) — snapshot as just another consumer of the shared live
- * pull. If the source is already warm and has a cached keyframe (V2 keyframe-prime), the joining
- * consumer receives that IDR immediately and we decode it with **no extra pull** — a snapshot while
- * someone else watches costs nothing on the wire. Otherwise we warm the source and wait for a clean
- * keyframe (the first IDR after a cold start is frequently partial, so skip it by default). Requires
- * `ffmpeg` for the Annex-B → JPEG decode.
+ * pull. A warm source reuses its upstream session; collection starts from live keyframes rather than
+ * a retained picture. A live source captures its next keyframe by default; a cold source skips the
+ * first keyframe because its first IDR is frequently partial. Requires `ffmpeg` for the Annex-B → JPEG decode.
  *
  * The returned dimensions are the ENCODED IMAGE's own, read back out of it — never the frame header's.
  * The header states the stream's geometry when the capture started, and a stream that reconfigures

package/dist/transport/p2p/p2p-session.d.ts

@@ -185,6 +185,10 @@ export declare class P2PSession extends EventEmitter {
      * change (the level-2 key arrived after an initial level-1 start), otherwise sends the 1139 nudge.
      */
     private readonly liveStartedChannels;
+    /** The `cipher_id` this connection's `CMD_GATEWAYINFO` reply named, once its negotiation has read it. */
+    private gatewayCipherId?;
+    /** The `n` of the last `[0x01, n]` header this connection sent in the clear — see {@link nextClearCommandBytes}. */
+    private clearCommandCount;
     private readonly unackedLiveStarts;
     private liveStartRetransmitTimer?;
     private readonly logger;
@@ -396,6 +400,9 @@ export declare class P2PSession extends EventEmitter {
      * `video_type` is 12, and `transaction` is the millisecond timestamp as a string. The device answers a
      * start carrying these values with a keyframe; `encryptkey` is the modulus it RSA-wraps each keyframe's
      * AES media key with (unwrapped by {@link decodeVideoFrame}).
+     *
+     * With `clearMsgId`, the body of a start sent in the clear: `{accountId, encryptkey, msg_id, streamtype: 1}`
+     * only, `msg_id` being `clearMsgId`, which changes from one start to the next.
      */
     private startLiveJson;
     /**
@@ -403,8 +410,20 @@ export declare class P2PSession extends EventEmitter {
      * (GCM, signCode 8, frame type 10) when the session has a negotiated key, else level-1 (AES-128-ECB,
      * signCode 1, frame type 11) — chosen by the session key, not the device family. The camera RSA-wraps
      * each keyframe's AES media key with the `encryptkey` modulus (unwrapped by {@link decodeVideoFrame}).
+     * A session that {@link sendsInTheClear} sends it unencrypted instead: signCode 0, frame type 0, header
+     * bytes `[0x01, n]` from {@link nextClearCommandBytes}, and `n` as the body's `msg_id`.
      */
     private sendStartLiveOwnSession;
+    /**
+     * Whether this session's own-session start and stop go in the clear: its `CMD_GATEWAYINFO` reply named
+     * `cipher_id` 0.
+     */
+    private sendsInTheClear;
+    /**
+     * Header bytes 10-11 of this connection's next command sent in the clear: `[0x01, n]`, with `n` counting
+     * those commands from 1 and never 0. A retransmit repeats its `n`, and the device's reply echoes it.
+     */
+    private nextClearCommandBytes;
     /**
      * Repeat unacknowledged own-session live starts until the device takes one. Runs only while a start is
      * outstanding.
@@ -475,6 +494,8 @@ export declare class P2PSession extends EventEmitter {
      *    `uint32`, the same 4-byte body as the attached talkback frames. The app sends this frame on closing
      *    an own-session camera's live view; the camera stops streaming on it within a second, and keeps
      *    streaming through the 1350-wrapped form.
+     *  - own-session on a session that {@link sendsInTheClear}: the same 4-byte body unencrypted, signCode 0,
+     *    header bytes from {@link nextClearCommandBytes}.
      *  - without a level-2 key: the bare 1004 command.
      */
     stopLiveMedia(channel?: number, accountId?: string, homeBaseAttached?: boolean): void;

package/dist/transport/p2p/readable-egress.d.ts

@@ -25,7 +25,6 @@ export interface ReadableEgressOptions {
 /**
  * Wrap a shared-source {@link Consumer} in a fresh Readable. The consumer is detached when the
  * Readable is destroyed/ended, so callers own the lifetime by owning the stream.
- * Frames arrive through onMedia; an empty video listener releases the keyframe-prime
- * because ConsumerImpl replays it when the first video listener is added.
+ * Frames arrive through onMedia, preserving their source-arrival metadata.
  */
 export declare function openReadableFromConsumer(consumer: Consumer, opts?: ReadableEgressOptions): Readable;

package/dist/transport/p2p/shared-live-source.d.ts

@@ -96,7 +96,6 @@ export interface SharedLiveSourceOptions {
  * back directly), plus the listener removal and arrival-timed feed the recording and readable egresses use.
  */
 export interface Consumer extends LiveStreamConsumer {
-    /** What this consumer holds the pull for. */
     /** Detach a previously registered listener (mirrors {@link LiveStreamHandle.on}). */
     off(event: "video", listener: (frame: LiveVideoFrame) => void): this;
     off(event: "audio", listener: (frame: LiveAudioFrame) => void): this;
@@ -104,18 +103,14 @@ export interface Consumer extends LiveStreamConsumer {
     off(event: "error", listener: (err: Error) => void): this;
     /** Subscribe to frames carrying the source-captured arrival time used by the prebuffer. */
     onMedia(listener: (item: TimedMediaFrame) => void): this;
-    /** True once the source has replayed a cached keyframe to this consumer (no GOP wait on join). */
-    readonly primed: boolean;
     /** Leave the source (refcount--). Idempotent. `stop()` is an alias (LiveStreamHandle). */
     detach(): void;
 }
 /**
  * One media frame retained with its transport-arrival time for prebuffer continuity.
  *
- * A video frame carries the coded configuration in force when it ARRIVED, because the item outlives that
- * moment: it is the unit a keyframe-prime replays to a consumer that joined later and the unit a prebuffer
- * drain hands over, and both have to announce the configuration their media was coded under rather than
- * whichever one is current by the time they are delivered.
+ * A video frame carries the coded configuration in force when it arrived, so a prebuffer drain
+ * announces the configuration its retained media was coded under.
  */
 export type TimedMediaFrame = {
     kind: "video";
@@ -145,8 +140,8 @@ export declare class SharedLiveSource {
      * {@link LiveStreamStartError}.
      */
     private delivered;
-    /** Last keyframe access unit seen — replayed to a joining consumer (keyframe-prime). */
-    private lastKeyframe?;
+    /** Whether the upstream has delivered a keyframe since its last teardown. */
+    private hasKeyframe;
     /** Last parameter sets the stream announced — see {@link parameterSets}. */
     private lastParamSets?;
     /**
@@ -164,14 +159,7 @@ export declare class SharedLiveSource {
     private warmRetryTimer?;
     /** Whether this warm-up has already asked its owner to replace the session. */
     private sessionReplacementAsked;
-    /**
-     * Whether the pending watch is a REUSE watch, which any frame settles.
-     *
-     * A cold warm-up needs a keyframe: nothing can be decoded without one. A join already holds the retained
-     * keyframe, so what its watch is missing is evidence the stream is still being served — and a delta frame is
-     * that evidence. Requiring a keyframe there let the deadline outlive an actively delivering stream whose
-     * group of pictures is longer than the window, and the timeout fails EVERY consumer.
-     */
+    /** A reuse watch settles on upstream media independently of each consumer's keyframe gate. */
     private reuseWatch;
     /** This source's opaque handle for tracing — see {@link SharedLiveSource.trace}. */
     private readonly traceId;
@@ -179,8 +167,8 @@ export declare class SharedLiveSource {
      * How many re-issues this watch has spent with nothing arriving since it was armed.
      *
      * What a stream delivered BEFORE the current watch is no evidence about now — a reused stream's upstream may
-     * have served plenty and since been dropped by the station, and the retained keyframe replayed to a joining
-     * consumer says nothing either. Only a frame arriving after the watch was armed does, and {@link delivered}
+     * have served plenty and since been dropped by the station. Only a frame arriving after the watch was
+     * armed proves current delivery, and {@link delivered}
      * is reset to track exactly that.
      *
      * The first re-issue is therefore a keepalive: a reuse cannot yet know which case it is in, and a keepalive
@@ -220,13 +208,13 @@ export declare class SharedLiveSource {
     get parameterSets(): ParamSets | undefined;
     /**
      * Attach a new consumer. Warms the stream on the first attach (or cancels a pending linger teardown
-     * and reuses the warm stream), then replays the cached keyframe so the consumer can decode at once.
+     * and reuses the warm stream). Delivery starts at the next live keyframe so every dependent
+     * picture follows its reference pictures without a gap from a cached keyframe.
      */
     attach(): Consumer;
     /**
      * Attach at the same instant a keyframe-aligned prebuffer snapshot is taken. The returned consumer
-     * is not separately keyframe-primed, so replaying `buffered` followed by its live events neither
-     * duplicates the newest IDR nor leaves a gap at the handoff.
+     * continues after `buffered` without waiting for another keyframe or duplicating the newest IDR.
      */
     attachWithPrebuffer(seconds: number): {
         consumer: Consumer;
@@ -298,24 +286,9 @@ export declare class SharedLiveSource {
      */
     private reissueStart;
     /**
-     * Watch a stream this consumer joined rather than warmed, so a dead one cannot pass for a live one.
-     *
-     * A reused stream hands a joining consumer the retained keyframe at once, which is evidence about the past:
-     * it says the stream WAS being served, not that it still is. A caller commits to media on that frame — a
-     * process, a negotiated session — so a stream the station has quietly stopped serving strands it with no
-     * deadline, because warming is what arms one and a reuse skips warming by definition.
-     *
-     * The watch is the warm-up's own, deadline and retry alike, and the first frame to arrive AFTER the join
-     * clears it, that being the only frame which says the stream is still being served. A stream still serving
-     * clears it long before the deadline fires; one that is not fails its consumers exactly as a cold start that
-     * never delivered would.
-     *
-     * The start is re-issued at once and then on the retry's cadence, because a station that stopped serving a
-     * channel when its last consumer left is the very case the retry recovers: waiting the whole window to
-     * report what one re-issued start can fix is a timeout where a stream was available.
-     *
-     * Nothing is armed while a watch is already pending, so several consumers joining one reused stream share the
-     * watch the first of them started.
+     * Watch an existing upstream with the warm-up retry and deadline. Any video or audio received after
+     * the watch begins confirms delivery and settles it. Each consumer's keyframe gate remains separate.
+     * Concurrent joins share a pending watch; the first join reissues the start immediately.
      */
     private watchReusedStream;
     /** Arm the battery budget timer (battery/solar sources) — replaces any pending budget/grace. */
@@ -328,7 +301,7 @@ export declare class SharedLiveSource {
     private onBudgetExpire;
     /** Re-push the battery budget (host called `extend()` from the notice), cancelling the auto-stop. */
     private extendBudget;
-    /** Settle a reuse watch on any frame — the join already holds a decodable picture. */
+    /** Settle a reuse watch on any upstream frame without changing consumer keyframe gates. */
     private settleReuseWatch;
     /** Stop the warm-up retry + deadline (the stream is confirmed live). */
     private clearWarmWatch;
@@ -410,7 +383,7 @@ export declare class SharedLiveSource {
     /** Refcount hit zero — arm the linger teardown. A new attach in the window cancels it. */
     private arm;
     /**
-     * Stop + drop the underlying stream and clear the prime/ring caches. Rebuildable via attach().
+     * Stop + drop the underlying stream and clear the keyframe/ring caches. Rebuildable via attach().
      *
      * The stream reference is dropped BEFORE stopping it, because `stop()` emits `"stop"` synchronously and
      * this source listens for that — so stopping re-enters `teardown` through {@link onUpstreamEnd}. Clearing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.5.0-beta.82",
+  "version": "0.5.0-beta.83",
   "description": "One typed TypeScript client for the Anker eufy v6 cloud — capability-driven devices, realtime events over P2P/MQTT/push, and live media",
   "license": "Apache-2.0",
   "author": "mega-yfue",