@mega-yfue/eufy-sdk 0.5.0-beta.9 → 0.5.0-beta.91

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

@@ -16,7 +16,10 @@ export interface DeviceRecord {
     deviceType?: number;
     model?: string;
     category?: string;
-    /** The app-shown device name (`device_name`); see {@link CloudRecord.name}. */
+    /**
+     * The app-shown device name: `alias_name` first on a vacuum, `device_name` first otherwise;
+     * see {@link CloudRecord.name}.
+     */
     name?: string;
     /** Parent HomeBase serial when attached (topology signal; see {@link CloudRecord.parentSn}). */
     parentSn?: string;
@@ -92,6 +95,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 +186,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/client/eufy-mega.d.ts

@@ -98,6 +98,8 @@ export declare class EufyMega extends EventEmitter {
     private readonly prewarmTiers;
     /** Transport-side owner of the P2P sessions + all wire senders. */
     private readonly p2p;
+    /** Transport-side owner of the T9000 station sessions (sibling of {@link p2p}). */
+    private readonly rtc;
     /** Transport-side owner of the secure-MQTT ff09 lock/garage command path (sibling of {@link p2p}). */
     private readonly mqtt;
     /** Transport-side owner of the legacy Tuya REST command path for non-AIoT vacuums (G-series). */
@@ -119,6 +121,8 @@ export declare class EufyMega extends EventEmitter {
     private readonly mapStores;
     /** Re-armed after each cloud-param poll; cancelled by {@link disconnect}. */
     private readonly pollTimer;
+    /** Armed while a failed push bring-up waits to be retried; cancelled by {@link disconnect}. */
+    private readonly pushRetryTimer;
     constructor(opts: EufyMegaOptions);
     /**
      * Builds the inbound listener that converts ThingClips DP maps to realtime capability state.
@@ -181,7 +185,8 @@ export declare class EufyMega extends EventEmitter {
      *
      * Skipped entirely for a device with a pollable cloud record, for an already-reporting device, and
      * when realtime is off — so the common path adds nothing. Resolving on timeout leaves a silent device
-     * read-less rather than failing the lookup.
+     * read-less rather than failing the lookup. A Tuya clean-line device waits on the Tuya cloud read the
+     * bring-up started, so no broker is brought up for it.
      */
     private awaitFirstRealtimeState;
     /**
@@ -241,8 +246,17 @@ export declare class EufyMega extends EventEmitter {
      * to land it under the property's name.
      */
     private rebindReads;
-    /** The distinct credential scopes the current MQTT roster needs — no devices on a scope, no connection. */
+    /**
+     * The distinct credential scopes the current MQTT roster needs — no devices on a scope, no connection.
+     * A Tuya clean-line device (`eufy_home_tuya`) needs none: the broker refuses its topics, and its state
+     * is read from the Tuya cloud.
+     */
     private mqttScopesInUse;
+    /**
+     * Read every Tuya clean-line device's DPs from the Tuya cloud and deliver them as realtime state,
+     * concurrently. A failed read is reported, not fatal, and leaves that device's state as it was.
+     */
+    private readTuyaDevices;
     /**
      * Emit a semantic capability event whose name is only known at runtime (`decodeCapabilityEvent`
      * returns a plain-string `event` + `payload`). The typed `emit` overload requires a literal event
@@ -266,6 +280,8 @@ export declare class EufyMega extends EventEmitter {
      * 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
@@ -291,6 +307,8 @@ export declare class EufyMega extends EventEmitter {
      * manager's own log, since by then nothing is waiting to receive it.
      */
     private recycleStandaloneSession;
+    /** Reopen a wired station that {@link recycleStandaloneSession} closed, while the generation that warmed it is current. */
+    private reopenWiredStation;
     /**
      * Whether the DECODED property now reads what the write asked for.
      *
@@ -395,6 +413,14 @@ export declare class EufyMega extends EventEmitter {
      * other kind is P2P.
      */
     private commandSinkFor;
+    /**
+     * 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` / `t8223` family flags.
+     */
+    private stationOf;
+    /** The vendor DeviceType of the station a device hangs off; `undefined` for a station itself. */
+    private stationDeviceTypeOf;
     /**
      * Combine explicit P2P media with the optional passive push-thumbnail provider.
      *
@@ -409,15 +435,32 @@ export declare class EufyMega extends EventEmitter {
      * Choose the transport stack for one command — the routing half of {@link commandSinkFor}.
      *
      * The `ff09-*` kinds share ONE frame that rides either transport, so each stack is asked whether it
-     * drives this device (`claimsDevice`) rather than inferring from the kind. `registry.require` throws
-     * on an unloaded serial, so a routing decision never silently falls through to the wrong transport.
+     * drives this device (`claimsDevice`) rather than inferring from the kind; `keyed-payload-actuate` (the
+     * classic Wi-Fi lock) is routed the same way, a channel-less actuation claimed by the stack that drives
+     * the lock. `registry.require` throws on an unloaded serial, so a routing decision never silently falls
+     * through to the wrong transport.
      * 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. A T8223 doorbell's route serves
+     * media only, and the RTC router refuses a command on it. Everything else is P2P.
      */
     private routeCommand;
+    /**
+     * The RTC route for a T9000 or T8N00 station or a device attached to one, or a T8223 doorbell that is its
+     * own station, decided by the station's model classification; `undefined` for any other device. A T8N00
+     * route carries its native `call` signalling; a T8223 route does too, and streams its video on a media
+     * track. The admin id is the station's `member.admin_user_id`, else the logged-in user.
+     */
+    private rtcRouteFor;
+    /**
+     * The RTC media provider for a station on a media-track route, or a camera attached to a T9000 whose
+     * `device_channel` resolves back to it on the station; `undefined` otherwise, unless an NVR camera has its own dedicated media call.
+     */
+    private rtcMediaFor;
     /**
      * 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
@@ -425,8 +468,9 @@ export declare class EufyMega extends EventEmitter {
      *
      * Side-effect: registers `eufy_home_tuya` devices with the Tuya command router so
      * the command dispatcher can resolve a eufy SN → Tuya devId without a separate lookup.
-     * The Tuya id is extracted from the device's raw cloud record (`tuya_uuid`, `tuya_virtual_id`,
-     * `tuya_device_id`, or `virtualId` fields — whichever is non-empty).
+     * The Tuya id is the first non-empty `tuya_uuid`, `tuya_virtual_id`, `tuya_device_id` or
+     * `virtualId` on the raw cloud record, else the device's serial: the app keys its Tuya device by
+     * the eufy device id, and a record that carries none of those fields is read under its serial.
      *
      * A partial cloud outage still resolves, with the devices that answered plus the ones already known — but a
      * session the cloud has rejected REJECTS, with {@link SessionExpiredError}. An empty list would be
@@ -529,6 +573,14 @@ export declare class EufyMega extends EventEmitter {
     private ensureRealtimeGeneration;
     /** Start all selected transports concurrently and settle their owning generation once. */
     private startRealtimeGeneration;
+    /**
+     * 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.
+     */
+    private retryPush;
     /** Resolve a generation with an immutable count snapshot; later transport completions are ignored. */
     private settleRealtimeGeneration;
     /**
@@ -571,6 +623,11 @@ export declare class EufyMega extends EventEmitter {
      * an unchanged VALUE, which is no state change to report but is fresh proof the device is alive. A
      * device absent from the previous pass is skipped — first sight is discovery, not a transition;
      * {@link deviceState} answers an initial reading.
+     *
+     * Then re-reads every Tuya clean-line robot from the Tuya cloud ({@link readTuyaDevices}): its state
+     * is not in the cloud record this pass diffs and no live channel carries it, so the poll is where it
+     * stays fresh. That read runs after the `try`, not inside it, so a cloud error on the list diff does
+     * not skip it; it reports its own failures and never rejects.
      */
     private pollOnce;
     /**
@@ -674,6 +731,11 @@ export declare class EufyMega extends EventEmitter {
      * — an already-open session resolves immediately.
      */
     connectStation(deviceSn: string, signal?: AbortSignal): Promise<void>;
+    /**
+     * 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: string): () => void;
     /** 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. */
     private warmWiredP2P;
@@ -748,6 +810,9 @@ export declare class EufyMega extends EventEmitter {
     /**
      * Subscribe the devices on one credential scope; a failing subscribe is reported, not fatal (one
      * unreachable device must not stop the rest of the roster from coming up).
+     *
+     * A Tuya clean-line device (`eufy_home_tuya`) is not subscribed: its state lives on the Tuya cloud,
+     * and the broker refuses its `eufy_home` topics on every credential.
      */
     private subscribeMqttDevices;
     /**

package/dist/client/types.d.ts

@@ -390,7 +390,7 @@ export type EufyMegaEventMap = {
             sn: string;
             property: string;
             param: number;
-            expected?: boolean | number | string;
+            expected: boolean | number | string;
             observed?: boolean | number | string;
             timeoutMs: number;
         }

package/dist/core/contracts.d.ts

@@ -171,9 +171,10 @@ export declare class RecordingDownloadError extends Error {
  * A recording downloaded from the station, as elementary streams.
  *
  * `video` is Annex-B H.264 in decode order, `audio` AAC-LC 16 kHz mono in ADTS framing (absent when the
- * recording carried none that could be decoded). `frames` counts the distinct video frames received,
- * `missingFrames` the ones the camera numbered but that never arrived, and `durationMs` spans the first
- * to the last received frame by the camera's own timestamps; `fps` is derived from those two stamps.
+ * recording carried none that could be decoded). `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.
  */
 export interface RecordingDownload {
     video: Buffer;
@@ -230,7 +231,7 @@ export interface StateConvergenceFailure {
     property: string;
     param: number;
     /** The RAW param value the write asked the device to report. */
-    expected?: boolean | number | string;
+    expected: boolean | number | string;
     /** What the param actually read when the deadline passed, absent where the device reported none at all. */
     observed?: boolean | number | string;
     timeoutMs: number;
@@ -248,7 +249,7 @@ export declare class StateConvergenceError extends Error {
     readonly sn: string;
     readonly property: string;
     readonly param: number;
-    readonly expected?: boolean | number | string;
+    readonly expected: boolean | number | string;
     readonly observed?: boolean | number | string;
     readonly timeoutMs: number;
     constructor(failure: StateConvergenceFailure);
@@ -263,10 +264,11 @@ export declare class StateConvergenceError extends Error {
  */
 export type ScalarForm = "auto" | "int-string" | "direct-binary";
 /**
- * The identity fields the `ff09` frame is built from — the AES key/IV inputs (`adminUserId`/`deviceSn`)
- * plus the frame's own direction bit and user-attribution fields (`A3`/`A4`/`A5`). Shared by the
- * actuate intent; the settings intents carry a narrower subset (the GET/SET frames omit the
- * user-attribution fields).
+ * The identity fields an actuation frame is built from — for `ff09`, the AES key/IV inputs
+ * (`adminUserId`/`deviceSn`) plus the frame's own direction bit and user-attribution fields
+ * (`A3`/`A4`/`A5`); for the keyed-payload envelope, the same five fields, sealed into its inner JSON.
+ * Shared by both actuate intents; the `ff09` settings intents carry a narrower subset (the GET/SET frames
+ * omit the user-attribution fields).
  */
 export interface Ff09Identity {
     /** Actuation direction: `true` = engage (lock / close), `false` = release (unlock / open) — the frame's `A3` byte. */
@@ -328,6 +330,11 @@ export type Command = {
     channel: number;
     mValue3?: number;
     form?: ScalarForm;
+    /**
+     * `"set-payload"`: a level-2 key that seals only this envelope (an RSA cipher's AES-128-ECB key)
+     * may seal it. Absent, the send waits for the key every level-2 sender uses.
+     */
+    level2Sender?: "set-payload";
 } | {
     kind: "p2p-privacy-burst";
     enabled: boolean;
@@ -347,6 +354,14 @@ export type Command = {
     channel: number;
 } | ({
     kind: "ff09-actuate";
+} & Ff09Identity)
+/**
+ * `keyed-payload-actuate` — a `SET_PAYLOAD` envelope whose inner JSON is sealed with a fresh AES key
+ * that the envelope itself carries, wrapped for the device's own public key. P2P-only; the router
+ * resolves the device key and the member display name from the device record.
+ */
+ | ({
+    kind: "keyed-payload-actuate";
 } & Ff09Identity) | {
     kind: "ff09-autolock";
     adminUserId: string;
@@ -457,7 +472,7 @@ export interface CommandSink {
     dispatch(cmd: Command): Promise<void>;
 }
 /**
- * Inbound Tuya DP event contract — the transport parses a ThingClips MQTT payload
+ * Inbound Tuya DP event contract — the transport parses the Tuya cloud DP read
  * (string-keyed object → numeric-keyed record) and delivers it through this interface. The
  * transport owns the parse; a capability owns the semantics (which DP id means what). Mirrors
  * {@link DpInboundFrame} for the AIoT MQTT path; the capability layer never names the Tuya framing.
@@ -487,6 +502,8 @@ export type VideoCodec = "h264" | "h265" | "av1";
  * headers promise decodes to no picture at all.
  */
 export interface LiveVideoFrame {
+    /** Source-reported unsigned 32-bit timestamp; unit and clock origin are unspecified. */
+    sourceTimestamp?: number;
     /** True on an IDR — a unit a consumer may begin decoding at, never a continuation of an earlier one. */
     keyframe: boolean;
     /**
@@ -541,6 +558,12 @@ export interface LiveVideoConfig {
     width: number;
     height: number;
 }
+/** Video frame paired with its original SDK source-arrival time. */
+export interface ReceivedVideoFrame {
+    readonly frame: LiveVideoFrame;
+    /** Wall-clock milliseconds when the shared source received the frame; preserved on replay. */
+    readonly timestampMs: number;
+}
 /**
  * Elementary-stream audio codec of a {@link LiveAudioFrame}. The station declares it per frame as a
  * byte in the `CMD_AUDIO_FRAME` header — unlike video, nothing is sniffed. These are the three values
@@ -548,19 +571,30 @@ export interface LiveVideoConfig {
  * 7 → `mp4a.40.39`); it fails the stream on anything else.
  */
 export type AudioCodec = "aac-lc" | "aac-eld" | "g711a";
+/** The codec a camera's speaker plays: `aac-eld` on a camera whose speaker plays it, `aac-lc` otherwise. */
+export type TalkbackCodec = Extract<AudioCodec, "aac-lc" | "aac-eld">;
 /**
  * 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`
@@ -655,10 +689,9 @@ export interface LiveStreamConsumer extends LiveStreamHandle {
      * consumer receives, so a consumer holding media it has not been told the configuration of is not a state
      * it can reach.
      *
-     * Per consumer, against what THIS consumer was last given: a consumer that joins mid-session is primed
-     * with a cached keyframe it did not witness arriving, and one that crosses its bound resynchronises onto
-     * a later IDR having skipped the frame the source saw the change on. Announcing what the source saw
-     * would leave both holding an encoder built for media they never received.
+     * Per consumer, against what this consumer was last given: a mid-session join begins at its next live
+     * keyframe, and a consumer crossing its queue bound resynchronises onto a later IDR. Each receives
+     * the configuration of the media it is delivered, even when another consumer has already seen it.
      *
      * Only a consumer announces this, never a bare {@link LiveStreamHandle}: it is read from the parameter
      * sets a shared source watches every frame for, which the raw pull underneath it does not do. That is
@@ -709,6 +742,10 @@ export interface LiveStreamConsumer extends LiveStreamHandle {
 export interface AbortableCall {
     signal?: AbortSignal;
 }
+/** Select an optical view; absence selects view 0. */
+export interface MediaSourceSelection {
+    view?: number;
+}
 export interface SharedSourceHints {
     /**
      * Power source, a runtime device fact (`"battery"` incl. solar, or `"wired"`) — never a device-family
@@ -734,6 +771,8 @@ export interface SharedSourceHints {
  * because an unbound model has no live client (hence `?.` at the call site).
  */
 export interface MediaProvider {
+    /** Optical view identifiers supported by this bound media route. */
+    views?: readonly number[];
     /**
      * Return the latest validated push thumbnail retained in memory. This passive operation performs no
      * network, storage, P2P, live-media, or transcoding work at call time. It rejects with
@@ -760,7 +799,7 @@ export interface MediaProvider {
         timeoutMs?: number;
         collectMs?: number;
         skipKeyframes?: number;
-    } & SharedSourceHints & AbortableCall): Promise<{
+    } & SharedSourceHints & AbortableCall & MediaSourceSelection): Promise<{
         jpeg: Buffer;
         width: number;
         height: number;
@@ -792,7 +831,7 @@ export interface MediaProvider {
      * stream?.stop(); // detach this consumer
      * ```
      */
-    live(opts?: SharedSourceHints & AbortableCall & Record<string, unknown>): Promise<LiveStreamConsumer>;
+    live(opts?: SharedSourceHints & AbortableCall & MediaSourceSelection & Record<string, unknown>): Promise<LiveStreamConsumer>;
     /**
      * Record `seconds` of video → an mp4/h264 buffer.
      *
@@ -809,13 +848,16 @@ export interface MediaProvider {
     }): Promise<Buffer>;
     /**
      * Open a video-only `node:stream` Readable over a shared source consumer — raw Annex-B bytes
-     * (default) or `objectMode` {@link LiveVideoFrame}s. Audio is available separately through
-     * {@link live} or muxed through {@link recordFragments}; it is never interleaved into raw video.
-     * The caller owns the Readable's lifetime, and destroying it releases the shared pull.
+     * (default) or `objectMode` {@link LiveVideoFrame}s. With objectMode and arrivalTime, it yields
+     * {@link ReceivedVideoFrame} envelopes whose original source-arrival time survives retained replay.
+     * Raw mode ignores arrivalTime. Audio is available separately through {@link live} or muxed through
+     * {@link recordFragments}; it is never interleaved into raw video. The caller owns the Readable's
+     * lifetime, and destroying it releases the shared pull.
      */
     openReadable?(opts?: {
         objectMode?: boolean;
-    } & SharedSourceHints & AbortableCall): Promise<import("node:stream").Readable>;
+        arrivalTime?: boolean;
+    } & SharedSourceHints & AbortableCall & MediaSourceSelection): Promise<import("node:stream").Readable>;
     /**
      * Continuously record the live feed as fragmented-MP4 (CMAF). The caller-owned
      * {@link FragmentRecordingHandle} yields an init segment then keyframe-bounded media fragments,
@@ -855,6 +897,7 @@ export interface MediaProvider {
      */
     p2pQuery?(subCmd: number, opts?: {
         timeoutMs?: number;
+        payload?: Record<string, unknown>;
     }): Promise<Record<string, unknown>>;
     /**
      * Generic control-payload request/reply query: send a `CONTROL_PAYLOAD` (1700) `{commandType,data}`
@@ -868,10 +911,11 @@ export interface MediaProvider {
     }): Promise<Record<string, unknown>>;
 }
 /**
- * An encoder that turns raw PCM into AAC-LC frames, supplied by the CALLER. The SDK ships none: the
- * device's audio path is fixed at AAC-LC 16 kHz mono, and every plausible encoder is either a native
+ * An encoder that turns raw PCM into AAC-LC frames, supplied by the CALLER. The SDK ships none: an
+ * `aac-lc` speaker plays AAC-LC 16 kHz mono, and every plausible encoder is either a native
  * dependency or an external process, both of which belong to the host rather than to a protocol SDK.
- * It is unnecessary where the audio is already AAC — see {@link TalkbackHandle}.
+ * It is unnecessary where the audio is already AAC — see {@link TalkbackHandle}. A camera whose speaker
+ * plays `aac-eld` refuses an encoder: a talkback opened with one is rejected before the speaker path opens.
  *
  * `encode` receives 16-bit little-endian mono PCM at 16 kHz and returns whole ADTS frames, zero or
  * more per call (an encoder buffers until it has a full 1024-sample block). `flush` drains a partial
@@ -886,17 +930,19 @@ export interface AacEncoder {
  * A live talkback session: audio pushed from the host to a camera's speaker, the mirror of
  * {@link LiveStreamHandle}'s inbound feed.
  *
- * Audio must be **AAC-LC, 16 kHz, mono, in ADTS frames** — what the device's path is fixed at, so a
- * stream at another rate or channel count is rejected rather than resampled (it would otherwise play
- * at the wrong pitch and speed). Feed it either way:
+ * Audio must be in the codec the camera's speaker plays, {@link TalkbackHandle.codec}:
+ *
+ *  - **`aac-lc`:** AAC-LC, 16 kHz, mono, in ADTS frames, through `write` / `writable()`. Chunk boundaries are
+ *    irrelevant; frames are recovered from the stream. With an {@link AacEncoder}, `write` takes 16-bit
+ *    little-endian mono PCM at 16 kHz instead.
+ *  - **`aac-eld`:** one raw AAC-ELD access unit with LD-SBR (16 kHz, mono, 512 samples) per `write`, or per
+ *    object-mode `writable()` write. No encoder applies.
  *
- *  - **ADTS AAC** — the default. Chunk boundaries are irrelevant; frames are recovered from the
- *    stream, so piping an encoder's output straight in works.
- *  - **PCM** — only when the handle was opened with an {@link AacEncoder}, which then does the
- *    conversion. `write` takes 16-bit little-endian mono PCM at 16 kHz instead.
+ * An `aac-lc` stream at another rate or channel count is rejected rather than resampled. An `aac-eld` unit longer
+ * than the device accepts is refused with an `error`.
  *
- * Frames are **paced** at their own playback rate (64 ms each) rather than flushed as fast as they
- * arrive, so feeding a file plays it at speed instead of overrunning the device. A live source keeps
+ * Frames are **paced** at their own playback rate (64 ms for `aac-lc`, 32 ms for `aac-eld`) rather than flushed as
+ * fast as they arrive, so feeding a file plays it at speed instead of overrunning the device. A live source keeps
  * the queue near-empty and is unaffected.
  *
  * @example
@@ -908,7 +954,16 @@ export interface AacEncoder {
  * ```
  */
 export interface TalkbackHandle {
-    /** Queue audio — ADTS frames, or PCM when an encoder was supplied. Partial frames are held. */
+    /**
+     * The codec this camera's speaker plays: `aac-eld` on a camera whose speaker plays it and whose stream on the same
+     * media session carries `aac-eld`, `aac-lc` otherwise, including when that stream carries no audio. It decides
+     * what {@link write} and {@link writable} take.
+     */
+    readonly codec: TalkbackCodec;
+    /**
+     * Queue audio: ADTS frames or PCM for `aac-lc`, one access unit per call for `aac-eld`. Partial ADTS frames are
+     * held.
+     */
     write(chunk: Buffer): void;
     /**
      * A `node:stream` Writable over {@link write}, for piping a file or an encoder's stdout. Applies
@@ -931,7 +986,7 @@ export interface TalkbackHandle {
      *
      * This deliberately does NOT fire on a merely-empty queue. A realtime source keeps the queue near
      * empty by design, so "queue is empty" arrives after the very first frame and stopping on it would
-     * cut the clip to 64 ms. {@link pending} is the instantaneous depth.
+     * cut the clip to one frame. {@link pending} is the instantaneous depth.
      */
     on(event: "finished", listener: () => void): this;
     /**

package/dist/core/store.d.ts

@@ -16,6 +16,10 @@ export interface PersistedSession {
     authToken: string;
     geoKey?: string;
     region: RegionShard;
+    /** The `countryCode` the session was logged in with; a different configured one logs in again. */
+    countryCode?: string;
+    /** The host `estimate_domain` answered; it names shards the region classification cannot (`ie`). */
+    estimatedDomain?: string;
     openudid: string;
     /** This install's reported device model + media user-agent, generated once and reused. */
     phoneModel?: string;

package/dist/core/types.d.ts

@@ -55,6 +55,8 @@ export interface EufyDevice {
      * every attached sensor of a T8010 — and serves only as a fallback for a device naming no parent.
      */
     stationSn?: string;
+    /** The device's channel on its station, as its record states it (`device_channel`); absent where it states none. */
+    channel?: number;
     /** Present (and non-empty) for P2P devices. */
     p2pDid?: string;
     /**