@mega-yfue/eufy-sdk 0.5.0-beta.66 → 0.5.0-beta.68

package/dist/model/device-family.d.ts

@@ -47,6 +47,8 @@ export declare const isHomeBase: (ctx: FamilyContext) => boolean;
 export declare const isStation9000: (ctx: FamilyContext) => boolean;
 /** T8N00 NVR, identified by its reported model. */
 export declare const isNvrT8N00: (ctx: FamilyContext) => boolean;
+/** Video Doorbell C31 (T8223), identified by its reported model. */
+export declare const isDoorbellT8223: (ctx: FamilyContext) => boolean;
 /** Wired doorbell (DeviceType.DOORBELL). */
 export declare const isWiredDoorbell: (ctx: FamilyContext) => boolean;
 /**

package/dist/model/types.d.ts

@@ -177,10 +177,11 @@ export interface PropertySpec {
      * consumable counters are `"number"` over one base64 string, and reading the value as a number is
      * exactly what must NOT happen at ingest.
      *
-     * Storage already keeps such a value intact — a non-numeric string cannot be coerced to a number, so
-     * it is passed through. What this flag changes is that the pass-through stops being reported as a
-     * mistake: a robot reporting ten Raw DPs on every push logged ten warnings a time saying its
-     * properties were misdeclared, which is how a real warning goes unread.
+     * Storage keeps such a value intact: a non-numeric string passes a `number` coercion unchanged, and
+     * on a `bool` property a string that is not a boolean wire form (`"0"`, `"1"`, `"true"`, `"false"`)
+     * is kept rather than read as `false`. The pass-through is not reported as a mistake: a robot
+     * reporting ten Raw DPs on every push logged ten warnings a time saying its properties were
+     * misdeclared, which is how a real warning goes unread.
      */
     raw?: true;
     /**

package/dist/transport/rtc/call-live.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Live view of a T8223 doorbell (Video Doorbell C31) over a portal `call` {@link RtcSession}.
+ *
+ * The doorbell is its own station and streams no PTCS framing: its video arrives as plain RTP on the
+ * offer's H.264 video m-line, which a {@link RtcPeerOptions.mediaTrack} peer hands over as `rtp`. This
+ * stream depacketizes it into whole Annex-B access units, one per frame. Each stream owns its session:
+ * starting it places the call, stopping it hangs up.
+ */
+import { EventEmitter } from "node:events";
+import type { LiveStreamHandle } from "../../core/contracts.js";
+import { type Logger } from "../../core/logger.js";
+import type { RtcSession } from "./session.js";
+/**
+ * H.264 RTP depacketizer (RFC 6184 single NAL / STAP-A / FU-A). Feed whole RTP packets; it calls `onUnit`
+ * with each complete Annex-B access unit when the marker bit closes it. A unit with a sequence gap or an
+ * unterminated fragment is dropped, never delivered short. RTCP multiplexed on the same transport (PT
+ * 200-207, which reads as 72-79 in the RTP payload-type bits) is skipped.
+ */
+export declare class H264Depacketizer {
+    private readonly onUnit;
+    private nals;
+    private fu;
+    private lastSeq;
+    private broken;
+    constructor(onUnit: (unit: Buffer, timestamp: number) => void);
+    push(packet: Buffer): void;
+}
+/** A `LiveStreamHandle` over one portal `call` to a T8223 doorbell. */
+export declare class RtcCallLiveStream extends EventEmitter implements LiveStreamHandle {
+    private readonly session;
+    private readonly logger;
+    private running;
+    private readonly depacketizer;
+    /** `session` is a session on a {@link RtcPeerOptions.mediaTrack} peer, not yet connected. */
+    constructor(session: RtcSession, logger?: Logger);
+    start(): this;
+    stop(): void;
+    private onUnit;
+    private fail;
+    private teardown;
+}

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

@@ -33,6 +33,11 @@ export interface RtcRoute {
     signalingMode?: "call" | "scall";
     /** Candidate policy used by the station's exchange; defaults to relay-only. */
     iceTransportPolicy?: "relay" | "all";
+    /**
+     * The station streams video as RTP on its offer's video track and serves no data channel, so it takes
+     * no portal command; see `RtcPeerOptions.mediaTrack`.
+     */
+    mediaTrack?: boolean;
     stationSn: string;
     /**
      * The station's `member.admin_user_id`, the account the session and the payload name; the logged-in
@@ -66,6 +71,7 @@ export declare class RtcCommandRouter {
     private readonly sessions;
     private readonly lives;
     private readonly warm;
+    private readonly callSources;
     constructor(deps: RtcCommandRouterDeps);
     dispatchCommand(route: RtcRoute, cmd: Command): Promise<void>;
     /**
@@ -73,6 +79,12 @@ export declare class RtcCommandRouter {
      * session. Recording has no wire here and is refused; the optional members it has no wire for are absent.
      */
     mediaProviderFor(route: RtcLiveRoute): MediaProvider;
+    /**
+     * Live view of a station on a {@link RtcRoute.mediaTrack} route: a live feed, a readable feed and a live
+     * still, from one shared source per station whose every warm-up places a fresh `call` on its own
+     * session. Recording has no wire here and is refused.
+     */
+    trackMediaProviderFor(route: RtcRoute): MediaProvider;
     /**
      * 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.
@@ -97,6 +109,7 @@ export declare class RtcCommandRouter {
      * not establish physical actuation. The command is sent once, bounded by {@link ACK_TIMEOUT_MS}.
      */
     private sendAwaitAck;
+    private newSession;
     private stationSession;
     /**
      * One bounded bring-up: the session is up when its command channel opens, and it fails, with the

package/dist/transport/rtc/peer.d.ts

@@ -12,6 +12,11 @@
  * plays the DTLS client (`active`) and opens its channels on the client's even SCTP stream ids, which
  * is what the hub pairs with.
  *
+ * With {@link RtcPeerOptions.mediaTrack} the remote is a T8223 doorbell instead: its offer bundles an Opus
+ * audio, an H.264 video and an `m=application` section, but it never completes the SCTP association. The
+ * application section is rejected before the offer is applied, no data channel is declared, and the
+ * video m-line's RTP is emitted as `rtp`.
+ *
  * The native peer is injectable.
  */
 import { EventEmitter } from "node:events";
@@ -30,6 +35,11 @@ export interface RtcPeerOptions {
     createPeer?: NativePeerFactory;
     /** Candidate policy for the station's exchange; the default is relay-only. */
     iceTransportPolicy?: "relay" | "all";
+    /**
+     * The remote streams its video as RTP on the offer's video m-line and serves no data channel: the
+     * offer's application section is rejected and the video track's packets are emitted as `rtp`.
+     */
+    mediaTrack?: boolean;
     logger?: Logger;
 }
 export interface RtcPeerEvents {
@@ -39,6 +49,8 @@ export interface RtcPeerEvents {
     data: [frame: Buffer, linkType: number];
     /** The hub echoed the portal keepalive on the command channel. */
     keepaliveEcho: [];
+    /** One RTP (or multiplexed RTCP) packet from the offer's video m-line, in a {@link RtcPeerOptions.mediaTrack} peer. */
+    rtp: [packet: Buffer];
     iceCandidate: [candidate: string];
     iceGatheringComplete: [];
     connectionState: [state: string];
@@ -58,6 +70,8 @@ export declare class RtcPeer extends EventEmitter<RtcPeerEvents> {
     private remoteMid;
     private handlingOffer;
     private channelsCreated;
+    private videoMid?;
+    private videoTrack?;
     private gatheringDone;
     /** Set by the framer's wire callback when the native channel refused a packet mid-send. */
     private wireSendFailed;
@@ -75,7 +89,9 @@ export declare class RtcPeer extends EventEmitter<RtcPeerEvents> {
      * 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.
+     * is taken as the local description: one read in `have-local-offer` is an offer. A
+     * {@link RtcPeerOptions.mediaTrack} peer applies the offer with its application section rejected,
+     * declares no channels, and adds remote candidates on the offer's first (bundle-tagged) mid.
      */
     handleRemoteOffer(offerSdp: string): Promise<string>;
     addRemoteCandidate(candidate: string): void;
@@ -99,6 +115,8 @@ export declare class RtcPeer extends EventEmitter<RtcPeerEvents> {
      * keepalive on the command channel is unframed and surfaces as `keepaliveEcho` instead.
      */
     private wireChannel;
+    /** Take the offer's video m-line as the one track whose RTP is emitted; any other track is left alone. */
+    private wireVideoTrack;
     private addNow;
     private flushPending;
 }

package/dist/transport/rtc/scall-sdp.d.ts

@@ -40,3 +40,11 @@ export declare function forceDtlsRole(sdp: string, role: "active" | "passive"):
  * the hub sends and parses. The native peer hands out the SDP attribute line (`a=candidate:...`).
  */
 export declare function toWireCandidate(candidate: string): string;
+/** The `a=mid` of the first m-section of `kind` in an SDP; `undefined` when it has none. */
+export declare function midOf(sdp: string, kind: "audio" | "video" | "application"): string | undefined;
+/**
+ * Reject an offer's `m=application` (data channel) section: port 0 and out of the BUNDLE group. The
+ * remote never completes the SCTP association, so a peer waiting on it fails; without it the peer
+ * connects on DTLS-SRTP alone.
+ */
+export declare function rejectDataSection(sdp: string): string;

package/dist/transport/rtc/session.d.ts

@@ -17,6 +17,9 @@
  * the signalling socket drops or {@link RtcSession.close} is called, even while the peer connection is
  * nominally up.
  *
+ * A session whose peer is a {@link RtcPeerOptions.mediaTrack} peer has no command channel: `close` fires
+ * when the peer fails or closes, and the video track's packets are emitted as `rtp`.
+ *
  * Both the signalling client and the peer are injectable.
  */
 import { EventEmitter } from "node:events";
@@ -37,6 +40,8 @@ export interface RtcSessionEvents {
     mediaData: [frame: Buffer];
     /** The hub echoed the portal keepalive on the command channel. */
     keepaliveEcho: [];
+    /** One packet of the video track, in a {@link RtcPeerOptions.mediaTrack} session. */
+    rtp: [packet: Buffer];
 }
 export declare class RtcSession extends EventEmitter<RtcSessionEvents> {
     private readonly opts;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.5.0-beta.66",
+  "version": "0.5.0-beta.68",
   "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",