@mega-yfue/eufy-sdk 0.6.0-beta.2 → 0.6.0-beta.21

package/dist/model/capabilities/camera.d.ts

@@ -475,6 +475,8 @@ export declare const CAMERA_MEMBERS: {
      *
      * `transaction` is part of the frame that was captured, so it is sent. The recording sibling's own
      * confirmed frame carries no such field; neither is inferred from the other.
+     *
+     * Not offered where the device reports the doorbell's own live-view quality (1705).
      */
     readonly streamingQuality: {
         readonly accepts: StreamingQualityName;
@@ -483,7 +485,7 @@ export declare const CAMERA_MEMBERS: {
         readonly kind: "enum";
         readonly enumValues: Readonly<Record<number, string>>;
         readonly provenance: "verified";
-        readonly available: typeof isCameraCodec;
+        readonly available: (ctx: AvailabilityContext) => boolean;
         readonly args: readonly [{
             readonly name: "quality";
             readonly kind: "enum";
@@ -596,6 +598,7 @@ export declare const CAMERA_MEMBERS: {
         timeoutMs?: number;
         skipKeyframes?: number;
     } | undefined) => Promise<Buffer<ArrayBufferLike>>)>;
+    /** The T8530 serves its live feed as a Readable too; its other media pulls stay withheld. */
     readonly openReadable: import("./members.js").ProvidedMember<"media", false | ((opts?: Parameters<NonNullable<MediaProvider["openReadable"]>>[0]) => Promise<import("node:stream").Readable>) | undefined>;
     readonly recordFragments: import("./members.js").ProvidedMember<"media", false | ((opts?: Parameters<NonNullable<MediaProvider["recordFragments"]>>[0]) => import("../../core/contracts.js").FragmentRecordingHandle) | undefined>;
     readonly downloadRecording: import("./members.js").ProvidedMember<"media", false | ((opts: Parameters<NonNullable<MediaProvider["downloadRecording"]>>[0]) => Promise<import("../../core/contracts.js").RecordingDownload>) | undefined>;

package/dist/model/capabilities/mower.d.ts

@@ -34,9 +34,9 @@ export declare const MOWER_DP: {
     readonly SPARSE_LAWN_OPTIMIZATION: 141;
 };
 /** The `net_media_type` (DP 134) range, as the schema lists it. */
-export declare const MOWER_NETWORKS: readonly ["None", "Wifi", "Cellular"];
+declare const MOWER_NETWORKS: readonly ["None", "Wifi", "Cellular"];
 /** The mower's network link (DP 134). */
-export type MowerNetwork = (typeof MOWER_NETWORKS)[number];
+type MowerNetwork = (typeof MOWER_NETWORKS)[number];
 /**
  * Every `mower` read, declared once.
  *
@@ -228,3 +228,4 @@ export declare const MOWER_MEMBERS: {
 export type MowerActions = Surface<typeof MOWER_MEMBERS>;
 /** `mower` — robot-mower state from its Tuya data points. */
 export declare const MOWER: CapabilityModule;
+export {};

package/dist/model/capabilities/vacuum-clean.d.ts

@@ -280,6 +280,16 @@ export declare function encodeSelectZonesClean(mapId: number, zones: readonly Va
  * @internal
  */
 export declare function encodeSceneClean(sceneId: number): string;
+/**
+ * Build one of the two DP 153 writes the vendor app sends when its map view opens: the time in
+ * microseconds, and on the second write field 2 set to `1`.
+ *
+ * Captured from the vendor app on the device's `cmd/…/req` leg, three times with the same layout. The
+ * product catalogue lists DP 153 as uplink-only (`WorkStatus`); the vendor app writes this message to it
+ * all the same. {@link VACUUM_CLEAN_MEMBERS.requestMap} dispatches both.
+ * @internal
+ */
+export declare function encodeMapWatch(nowMs: number, watching: boolean): string;
 /**
  * Build a whole-floor auto clean carrying an `AutoClean` payload of one pass.
  * @internal
@@ -1986,6 +1996,19 @@ export declare const VACUUM_CLEAN_MEMBERS: {
     readonly startScene: import("./members.js").MethodMember<(sceneId: number) => Promise<void>> & {
         available: (ctx: import("./types.js").CommandContext) => boolean;
     };
+    /**
+     * Ask the robot to push its whole map — plane, room outline, room list and restricted zones — on the
+     * map stream, as the vendor app does when its map view opens: two DP 153 writes, the time and then the
+     * time with field 2 set (see {@link encodeMapWatch}).
+     *
+     * A docked robot sends no map of its own accord, so this is how its room ids and names become
+     * readable without a clean. The map arrives on the stream like any other, not as this call's result.
+     *
+     * WATCHED: sent to a docked robot, it pushed its whole map within a second.
+     */
+    readonly requestMap: import("./members.js").MethodMember<() => Promise<void>> & {
+        available: (ctx: import("./types.js").CommandContext) => boolean;
+    };
     /**
      * State the cleaning settings a run uses — `CleanParamRequest.clean_param` over DP 154.
      *

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

@@ -52,7 +52,7 @@ 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;
-/** PoE cameras whose media is served by their NVR's portal call. */
+/** A camera attached to a T8N00 whose media the NVR's call serves. */
 export declare const isNvrMediaCamera: (ctx: FamilyContext) => boolean;
 /** PoE S4 camera with independently streamed fixed and movable optical views. */
 export declare const isNvrDualLensCamera: (ctx: FamilyContext) => boolean;

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

@@ -112,6 +112,7 @@ export declare const DeviceType: {
     readonly LOCK_85D0: 202;
     readonly LOCK_85V0: 203;
     readonly LOCK_85P0: 209;
+    readonly WALL_LIGHT_CAM_T86C1: 298;
     readonly NVR_S4_MAX: 300;
     readonly CAMERA_POE_S4: 301;
     readonly WALL_LIGHT_CAM_81A0: 10005;

package/dist/transport/http/mega-client.d.ts

@@ -1,6 +1,7 @@
 import { type SessionEntry } from "../../core/crypto.js";
 import { type SessionStore } from "../../core/store.js";
 import { type Logger } from "../../core/logger.js";
+import type { EufyDevice } from "../../core/types.js";
 import type { SecureMqttCredentials } from "../mqtt/secure-mqtt.js";
 export type RegionShard = "eu-pr" | "us-pr";
 /**
@@ -354,11 +355,11 @@ export declare class MegaHttpClient {
     /** Authed call to a mega service host: app-{service}-{region}.eufy.com. */
     post<T = unknown>(service: string, path: string, body?: unknown, headerOverrides?: Record<string, string>): Promise<T>;
     /**
-     * Fetch the per-station DSK key used in the P2P cloud-lookup payload. Mirrors
+     * Fetch the per-station DSK key using each station's reported cloud category. Mirrors
      * the legacy `get_dsk_keys` body shape on the mega devicerelation service.
      * The P2P *local* lookup path does not need this; only the cloud path does.
      */
-    getDskKeys(stationSns: string[], priorDsks?: Record<string, string>): Promise<Record<string, {
+    getDskKeys(stations: ReadonlyArray<Pick<EufyDevice, "sn" | "category">>, priorDsks?: Record<string, string>): Promise<Record<string, {
         dskKey: string;
         expiration: number;
     }>>;

package/dist/transport/mqtt/biz-stream.d.ts

@@ -12,44 +12,41 @@ export declare const BIZ_PROTOCOL: {
     readonly LIVE_PHOTO: 43;
 };
 /**
- * The channels a map frame can arrive on, by id.
+ * The channels a map frame arrives on, by id, as a robot's own frames identify them.
  *
- * **The trap.** Ids 1–10 come from `Metadata.ChanIds` in `stream.proto`, where each *field* names a
- * message and each field's *value* is the id the device chose for it. The names below pair each
- * channel with its field NUMBER, because that is the numbering the vendor ships and the one a live
- * capture shows — but a device announcing a `Metadata` frame is announcing its own numbering, and a
- * firmware that renumbers would make this table wrong without making it look wrong. Anything that
- * *decodes* a channel's bytes must therefore prefer a device-declared mapping when one has been seen;
- * this table is the default to fall back on, not an authority.
+ * Each id is paired with the `stream.proto` message whose field layout its frames carry, which is not
+ * the field-number order of `Metadata.ChanIds`: the cell plane (`Map`) arrives on 2, its room outline
+ * on 4, the room list on 5, the restricted zones on 6, the robot's pose (`DynamicData`) on 7, the map's
+ * `MapDescription` on 60 and a whole `MapBackup` on 68. A `Metadata` frame would declare a device's own numbering; none has been seen,
+ * so none is read, and this table is the numbering every frame is read by.
  *
- * Channel 0 is the exception and is not in `ChanIds` at all: the app hard-codes it, routing it to a
- * scene-data event rather than a map one, and asks for the scene list on it by number. That one is
- * fixed.
+ * Only channels whose message is identified are listed. A channel whose frames carry too little to
+ * identify, or that carries a message nothing here reads, is absent.
+ *
+ * Channel 0 is not in `ChanIds` at all: the app hard-codes it, routing it to a scene-data event rather
+ * than a map one, and asks for the scene list on it by number.
  */
 export declare const BIZ_CHANNEL: {
     /** Scene (room-group) data. Hard-coded in the app, not part of `ChanIds`. */
     readonly SCENES: 0;
-    readonly MAP_INFO: 1;
-    readonly PATH: 2;
-    readonly ROOM_OUTLINE: 3;
-    readonly ROOM_PARAMS: 4;
-    readonly RESTRICTED_ZONE: 5;
-    readonly DYNAMIC_DATA: 6;
-    readonly TEMPORARY_DATA: 7;
-    readonly OBSTACLE_INFO: 8;
-    readonly MAP_DATA: 9;
-    readonly CRUISE_DATA: 10;
+    readonly MAP_DATA: 2;
+    readonly ROOM_OUTLINE: 4;
+    readonly ROOM_PARAMS: 5;
+    readonly RESTRICTED_ZONE: 6;
+    readonly DYNAMIC_DATA: 7;
+    readonly MAP_DESCRIPTION: 60;
+    readonly MAP_BACKUP: 68;
 };
-/** A channel's name under the default numbering — see the trap in {@link BIZ_CHANNEL}. */
+/** A channel's name under the {@link BIZ_CHANNEL} numbering. */
 export type BizChannel = keyof typeof BIZ_CHANNEL;
 /**
- * Name a channel id under the default numbering, or `undefined` for an id the vendor's table does not
- * list. Not a substitute for a device-declared mapping where one exists.
+ * Name a channel id under the {@link BIZ_CHANNEL} numbering, or `undefined` for an id it does not list.
+ * Not a substitute for a device-declared mapping where one exists.
  */
 export declare function bizChannelName(id: number): BizChannel | undefined;
 /** One frame off the map stream, unwrapped as far as its bytes but not decoded. */
 export interface BizMapFrame {
-    /** Which channel the bytes belong to. Compare against {@link BIZ_CHANNEL}, mindful of its trap. */
+    /** Which channel the bytes belong to. Compare against {@link BIZ_CHANNEL}. */
     readonly channelId: number;
     /**
      * The vendor's `clear_type`. Forwarded, not interpreted: the app passes it straight through to its

package/dist/transport/p2p/audio-frame.d.ts

@@ -12,3 +12,16 @@ export declare const AUDIO_TYPE_OFFSET = 5;
  * itself when a stream produces no audio at all, to feed its decoder silence.
  */
 export declare const AUDIO_CODECS: Readonly<Record<number, AudioCodec>>;
+/**
+ * Whether an audio frame is sealed: after its header, a 16-byte GCM tag and a 12-byte nonce precede the
+ * `u32@0` bytes its header declares, where a frame in the clear carries those bytes straight after the header.
+ * A stream whose keyframes wrap their media key in an ECIES envelope seals its audio this way, measured on
+ * HomeBase recordings and on HomeBase 3 live streams answering a P-256 start.
+ */
+export declare function isSealedAudio(frame: Buffer): boolean;
+/**
+ * The payload of a sealed audio frame ({@link isSealedAudio}), opened with AES-256-GCM under `mediaKey`, the
+ * media key of the keyframe before it, with the video frames' AAD. Answers `undefined` for a frame that is not
+ * sealed or does not authenticate under that key.
+ */
+export declare function openSealedAudio(frame: Buffer, mediaKey: Buffer): Buffer | undefined;

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

@@ -224,8 +224,8 @@ export declare function buildRawCommandPayload(data: Buffer, channel?: number, s
 export declare function buildAckPayload(dataTypeHeader: Buffer, seqNo: number): Buffer;
 /** Parse the 16-byte data-frame header that follows the "XZYH" magic. */
 export declare function parseDataFrameHeader(frame: Buffer): P2PDataFrameHeader;
-/** Parse a LOOKUP_ADDR or RLY_TO message's leading address record. */
-export declare function parseLookupAddr(msg: Buffer): Address;
+/** A LOOKUP_ADDR message's leading address record, or `undefined` for a message too short to carry it. */
+export declare function parseLookupAddr(msg: Buffer): Address | undefined;
 /** The relay servers a LIST_REQ_ACK names, in the order listed, without the unspecified address; records past the message's end are dropped. */
 export declare function parseRelayList(msg: Buffer): Address[];
 /** A RLY_PORT_ACK's mark and relay port, or `undefined` for a message too short to carry them. */

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

@@ -62,6 +62,8 @@ export interface P2PRouterDeps {
     onClose: (stationSn: string) => void;
     onError: (err: Error) => void;
     onLevel2Ready: (stationSn: string, cipherId: number) => void;
+    /** The station answered on its own session at `atMs` — a PONG or an ACK from the connected peer. */
+    onPeerAnswer?: (stationSn: string, atMs: number) => void;
     /** A raw decoded frame — the client emits the low-level `p2p` event + runs the semantic decode. */
     onFrame: (stationSn: string, frame: P2PFrame) => void;
     /**
@@ -102,6 +104,18 @@ export declare class P2PCommandRouter {
      * {@link liveSources} is a claim in flight.
      */
     private readonly liveSessionKeys;
+    /**
+     * The live source build in flight per `${parentSn}:${channel}`, settled once its connection is opened
+     * or refused.
+     *
+     * A build awaits its media session before it can file the source in {@link liveSources}, so a second
+     * request for the same camera in that window finds nothing cached. Building a second source there
+     * overwrites the first, and the orphan's teardown then closes the connection the cached one streams
+     * on. A request that finds a build here waits for it, until its own signal aborts, then resolves its
+     * session again and reuses what the build filed, or builds its own when that build failed. The entry
+     * is removed when the build settles and its promise never rejects, so each wait ends on a later state.
+     */
+    private readonly liveSourceBuilds;
     /**
      * The open talkback per `${parentSn}:${channel}`, if any. The device plays one audio stream at a
      * time and the session carries one audio sequence, so this path is exclusive where a live pull is
@@ -220,6 +234,11 @@ export declare class P2PCommandRouter {
      * so a start issued before the key arrives is dropped as `media-command-unsent`, and the stream then
      * shows nothing until a later keepalive tick happens to find the key. A connected session that cannot
      * carry the start is not a connected session, so this refuses rather than returning one.
+     *
+     * A session refused its key within the grace, or never connected, is closed and dropped from the manager at
+     * once. Nothing else releases it: no source holds it, a wired station's session never idles out, and the
+     * manager hands the same session to every later open of the camera, so the next open dials a fresh
+     * connection instead. A session another open has since replaced is left to its own close.
      */
     private openMediaSession;
     /**
@@ -394,8 +413,9 @@ export declare class P2PCommandRouter {
      * {@link releaseLingeringSiblings}. A pull with consumers is never touched. The release runs before the
      * reuse branch, so a reuse frees the station as a cold start does.
      *
-     * `mayOpenOwnSession` decides whether a camera that finds the station's own session claimed may open a
-     * connection of its own for it. Only the continuous-pull egresses pass it. A still must not: it wants one
+     * `continuous` decides whether a camera that finds the station's own session claimed may open a
+     * connection of its own for it; on an {@link OWN_LIVE_SESSION_MODELS} station it always gets one, and an
+     * unwatched source left on the station's session is rebuilt there. Only the continuous-pull egresses pass it. A still must not: it wants one
      * frame, and a socket plus a level-2 negotiation per thumbnail is a cost a tile refresh cannot justify —
      * so a still asked for while a sibling is being watched contends as it always did, and the caller's
      * retained image answers it. A live view still outranks a tile; what changed is that two live views no
@@ -404,7 +424,7 @@ export declare class P2PCommandRouter {
      * The session goes into a {@link HeldSession} cell, so it can be replaced under a source that stays in
      * place.
      */
-    sharedLiveSourceFor(sn: string, opts?: SharedLiveOpts, mayOpenOwnSession?: boolean): Promise<SharedLiveSource>;
+    sharedLiveSourceFor(sn: string, opts?: SharedLiveOpts, continuous?: boolean): Promise<SharedLiveSource>;
     /**
      * Tear down any pull on this station that is lingering for ANOTHER camera, before starting this one.
      *
@@ -559,12 +579,17 @@ export declare class P2PCommandRouter {
      * yield CMAF fragments (init segment first, then a `moof`+`mdat` per keyframe boundary) muxed by the
      * dependency-free internal fMP4 muxer. The returned recording handle exposes battery-budget notices
      * and detaches its consumer on `stop`, iterator return, or iterator throw. No ffmpeg.
+     *
+     * It is a continuous pull only on an {@link OWN_LIVE_SESSION_MODELS} station; elsewhere it never opens a
+     * connection of its own.
      */
     recordFragments(sn: string, opts?: {
         fragmentSeconds?: number;
         eccPrivateKey?: Buffer;
         keepAliveMs?: number;
     } & SharedSourceHints): FragmentRecording;
+    /** Whether `stationSn` is an {@link OWN_LIVE_SESSION_MODELS} station. */
+    private ownsLiveSession;
     /**
      * **Generic P2P request/reply query.** Sends a `SET_PAYLOAD` (1350) wrapper carrying `subCmd` on the
      * device channel, then resolves with the reply frame's `payload` — the `NOTIFY_PAYLOAD` (1351)

package/dist/transport/p2p/database-wire.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Database wire — the ids and the whole-table query a station's on-station table and stored-image
+ * reads are built from.
+ *
+ * A HomeBase answers them over its P2P session and a T9000 over its portal control channel, with the
+ * same inner payloads, so both transports build their reads from this one module. The barrel does not
+ * re-export it: these are wire ids, not part of the package surface.
+ *
+ * @module p2p/database-wire
+ */
+/** CMD_DATABASE_IMAGE (1308) — fetch one stored image by its on-station path. */
+export declare const CMD_DATABASE_IMAGE = 1308;
+/** CMD_DATABASE (1306) — query one on-station table; reply carries `{cmd:10000,count,data:[…]}`. */
+export declare const CMD_DATABASE = 1306;
+/**
+ * Inner query cmds carried in a {@link CMD_DATABASE} payload. `FULL_TABLE` reads one table whole;
+ * `COMBINATION_WITH_AI` is the AI event-history read that bundles the face roster.
+ */
+export declare const DB_QUERY: {
+    readonly FULL_TABLE: 10000;
+    readonly COMBINATION_WITH_AI: 10011;
+    readonly QUERY_LOCAL: 10017;
+};
+/** How long a station's database reply has to arrive whole, when the caller states no bound. */
+export declare const DB_TABLE_TIMEOUT_MS = 15000;
+/**
+ * The query params the vendor app sends with a whole-table `CMD_DATABASE` read (inner `cmd 10000`).
+ * `count` bounds the row count.
+ */
+export declare function fullTableQuery(count?: number): Record<string, unknown>;

package/dist/transport/p2p/level2-settle.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The bound a caller waits for the level-2 negotiation to SETTLE, measured from connect.
+ *
+ * For a caller that picks its seal once from `P2PSession.hasLevel2Key` and has no second chance. A media
+ * start reads the key on every send and is re-issued by the warm-up, so it needs no wait; a property write
+ * framed level-1 to a family that only accepts level-2 is ignored, and nothing re-frames it. Session-scoped,
+ * so a station that offers no key does not charge this to every later command.
+ */
+export declare const LEVEL2_SETTLE_MS = 8000;

package/dist/transport/p2p/live-stream.d.ts

@@ -7,9 +7,11 @@
  *  - **Plaintext** (`signCode 0`, e.g. HomeBase-attached cameras): a fixed 22-byte frame header
  *    (`parseVideoFrameHeader`) followed directly by Annex-B NAL units — verified live (960×540,
  *    keyframe = header flag bit0). We strip the 22-byte header.
- *  - **Encrypted** (E2E cameras): the body is AES-256-GCM under a per-stream media key wrapped in a
- *    keyframe ECIES envelope. If an `eccPrivateKey` is supplied we run `VideoFrameDecoder`; otherwise
- *    those frames are skipped (no key → no video).
+ *  - **Encrypted keyframes**: either the AES-256-GCM body under a media key wrapped in an ECIES envelope
+ *    for an offered P-256 key ({@link VideoFrameDecoder}), or an AES-ECB head under a media key wrapped for
+ *    the session's RSA key ({@link P2PSession.decodeVideoFrame}). An attached camera's start on a station
+ *    with a {@link P2PSession.mediaEccPrivateKey} offers that P-256 key first, so its stream decodes with
+ *    that pair unless `eccPrivateKey` names another.
  *
  * Emits: `video` ({@link LiveVideoFrame} — Annex-B), `audio` ({@link LiveAudioFrame}), `start`, `stop`,
  * `error`.
@@ -54,7 +56,10 @@ export interface LiveStreamOptions {
      * however long the station keeps serving that sibling instead of this one.
      */
     channel?: number;
-    /** Camera ECC private key (32B) for E2E/encrypted cameras; omit for plaintext cameras. */
+    /**
+     * P-256 private key (32B) whose public point the camera wraps each keyframe's media key for. Defaults, on an
+     * attached camera, to the session's `P2PSession.mediaEccPrivateKey`, the pair its start offers.
+     */
     eccPrivateKey?: Buffer;
     /** Admin account id — required for the level-2 (`signCode 8`) media-start payload selecting a camera. */
     accountId?: string;
@@ -112,6 +117,8 @@ export declare class LiveStream extends EventEmitter {
     private tracedFirstVideoUnit;
     private tracedFirstKeyframe;
     private tracedDecodeFailures;
+    /** How the frame that opened the latest access unit was read; see {@link settleStartKey}. */
+    private unitOpenedBy;
     private tracedFirstForeignFrame;
     private stallTimer?;
     /**
@@ -173,6 +180,7 @@ export declare class LiveStream extends EventEmitter {
     stop(): void;
     /** Extract the Annex-B payload from a plaintext 1300 frame (fixed 22-byte header), or undefined. */
     private plaintextAnnexB;
+    /** Emit one accepted media frame; an audio frame with no bytes past its header emits nothing. */
     private onFrame;
     /**
      * Whether this stream may take `frame` — the demultiplexer for a station that serves several cameras.
@@ -198,11 +206,30 @@ export declare class LiveStream extends EventEmitter {
      */
     private acceptsMedia;
     /**
-     * The Annex-B payload of a frame that starts an access unit. The session decodes it when it can (it
-     * holds the RSA private key, and handles the plaintext form); the legacy header-strip and the ECIES
-     * {@link VideoFrameDecoder} are the fallbacks for an E2E camera.
+     * The Annex-B payload of a frame that starts an access unit. The authenticated ECIES/GCM
+     * {@link VideoFrameDecoder} goes first: its HMAC and GCM checks fail closed on a frame not sealed for its
+     * key. The session's RSA path cannot: on Node ≥ 24.5, PKCS#1 v1.5 decryption of a key not wrapped for it
+     * returns pseudo-random bytes instead of throwing (implicit rejection), which would decode an ECC
+     * keyframe into noise. The session's decode, which also passes plaintext frames, and the header strip
+     * follow. A payload that opens an access unit records how it was read: by the ECIES path, or otherwise by
+     * its sign code, sealed (`"rsa"`) or in the clear (`"plain"`).
      */
     private annexbOf;
+    /**
+     * Tell the session how this keyframe was opened, which answers the attached starts on this channel
+     * ({@link P2PSession.settleAttachedKey}), and re-issue the start when the session asks for one: a plaintext
+     * keyframe answering the session's P-256 offer, from a camera that did not use the point, which the next
+     * start asks with RSA. Only a delivered keyframe answers: a frame no key opens, or a continuation without the
+     * frame that opened its unit, delivers nothing.
+     */
+    private settleStartKey;
+    /**
+     * The payload of an audio frame. On a stream with an ECIES decoder, a sealed frame ({@link isSealedAudio}) is
+     * opened under the media key of the latest keyframe, and answers `undefined` when it does not open or arrives
+     * before any keyframe gave a media key, since its bytes are ciphertext. Every other frame is the bytes after
+     * its header, empty for a frame that carries only its header.
+     */
+    private audioPayload;
     /**
      * Report an access unit the transport could not complete.
      *

package/dist/transport/p2p/live-trace.d.ts

@@ -23,6 +23,8 @@ export type LiveTrace =
     topology: "attached" | "own";
     action: "start" | "keepalive";
     level2: boolean;
+    /** The media-key type an attached start offered. */
+    key?: "ecc" | "rsa";
 }
 /** The device acknowledged a retained start, or that start was repeated / abandoned unacknowledged. */
  | {
@@ -137,10 +139,10 @@ export type LiveTrace =
  *
  * Every ending of a level-2 wait carries one of these reasons, so a start refused for want of a key is
  * accounted for however it ended. `grace-elapsed` is a wait that ran out and states how long was waited;
- * the rest are answered without waiting, because the negotiation is one-shot per connection and a
- * concluded one is final. `no-cipher-key` and `derivation-failed` are about this account's cipher
- * material, `not-negotiating` and `session-closed` about the station or its connection — and only a
- * reason reached under a negotiation has a cipher to name.
+ * the rest are answered without waiting, because a concluded negotiation stays concluded until a
+ * re-prompt for `CMD_GATEWAYINFO` re-opens it. `no-cipher-key` and `derivation-failed` are about this
+ * account's cipher material, `not-negotiating` and `session-closed` about the station or its connection —
+ * and only a reason reached under a negotiation has a cipher to name.
  *
  * A `grace-elapsed` start proceeds at level 1 where it has such a form, and not at all where it does not.
  */