@mega-yfue/eufy-sdk 0.5.0-beta.0 → 0.5.0-beta.10

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

@@ -43,6 +43,8 @@ export declare const isOutdoorPanTilt: (ctx: FamilyContext) => boolean;
 export declare const isFloodLight: (ctx: FamilyContext) => boolean;
 /** HomeBase-family hub (has a speaker/alarm) — a station EXCLUDING the NVRs, per `HOMEBASE_TYPES`. */
 export declare const isHomeBase: (ctx: FamilyContext) => boolean;
+/** HomeBase S1 Pro (`STATION_9000`), the station the app drives over its WebRTC control channel. */
+export declare const isStation9000: (ctx: FamilyContext) => boolean;
 /** Wired doorbell (DeviceType.DOORBELL). */
 export declare const isWiredDoorbell: (ctx: FamilyContext) => boolean;
 /**

package/dist/model/registry.d.ts

@@ -48,7 +48,8 @@ export declare function resolveDevice(rec: CloudRecord): ResolvedDevice;
  * The property manifest for a device, from its capabilities and the record's facts. The single place
  * an {@link AvailabilityContext} is built — so a family-gate (`available`) and a per-model enum
  * (`enumValuesFor`) are decided from the same truthful, session-free view on every path (initial
- * resolve and {@link Device.reresolve}). Populated only from what a record carries, never transport
- * fields a live session hasn't produced.
+ * resolve and {@link Device.reresolve}). Populated only from what a record carries: its cloud params and
+ * the params its device reported over realtime, the same evidence a bound getter is gated on. Never
+ * transport fields a live session hasn't produced.
  */
 export declare function resolveProperties(rec: CloudRecord, codec: Codec, capabilities: Capability[]): PropertySpec[];

package/dist/model/types.d.ts

@@ -286,6 +286,12 @@ export interface CloudRecord {
     parentSn?: string;
     /** Reported param_type → raw value. Presence of a param is a capability signal. */
     params?: Record<number, string>;
+    /**
+     * Params the device reported over its realtime channel, keyed in the device's own namespace. A line
+     * whose state exists only on that channel carries none of it in {@link params}, so this is the
+     * evidence an availability gate on such a param is decided from.
+     */
+    dpParams?: Record<number, string>;
 }
 /** The fully-resolved device shape produced by the 3-tier resolver. */
 export interface ResolvedDevice {

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

@@ -209,6 +209,8 @@ export interface SignedRetry {
 export declare class MegaHttpClient {
     private readonly cfg;
     private region;
+    /** The host `estimate_domain` answered, persisted with the session. */
+    private estimatedDomain;
     private bootstrapDomain?;
     private sessionKey?;
     /** Per-host ECDH session keys for non-mega gateways (e.g. eufylife) keyed by host. */
@@ -275,6 +277,21 @@ export declare class MegaHttpClient {
     } | undefined;
     /** The active region shard (e.g. `"eu-pr"`, `"us-pr"`), set after {@link login} or a region override. */
     get regionShard(): RegionShard;
+    /**
+     * The shard the RTC signalling signs on: the regional prefix of the estimated domain
+     * (`…-ie-…`/`…-ie.` → `ie-pr`), else {@link regionShard}. The eu/us classification cannot name shards
+     * like `ie-pr`, whose accounts need the IE sign host and cluster.
+     */
+    get rtcShard(): string;
+    /**
+     * The credentials the RTC signalling needs; `undefined` while logged out. The sign is refused
+     * ("gtoken not equal userid") unless its gtoken is the one every authed HTTP call carries.
+     */
+    rtcIdentity(): {
+        authToken: string;
+        userId: string;
+        gtoken: string;
+    } | undefined;
     /**
      * The name commands attribute themselves to — {@link MegaClientConfig.accountName} when the config
      * pins one (trimmed; blank counts as unset), otherwise the logged-in account's display name, which

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

@@ -258,11 +258,14 @@ export declare class P2PCommandRouter {
      */
     dispatchCommand(sn: string, cmd: Command): Promise<void>;
     /**
-     * Restart a HomeBase. `RESTART_HUB` (1034) is a station-scalar on the broadcast channel 255: a
-     * level-2 frame whose body is `[u32 value][account_id padded]` — the same shape as the hub
-     * alarm-volume control. ✅ Wire-confirmed byte-exact from a capture of the app's own Restart
-     * (2026-08-03) and HW-tested: the captured frame carried value `0` and rebooted the hub. Replays
-     * like every other level-2 control, so a single dropped datagram doesn't lose it.
+     * Restart the station that owns `sn`'s P2P session. `RESTART_HUB` (1034) is a station-scalar on the
+     * broadcast channel 255 whose body is `[u32 value][account_id padded]`, value `0`. ✅ Wire-confirmed
+     * byte-exact as a level-2 frame from a capture of the app's own HomeBase Restart (2026-08-03).
+     *
+     * The seal follows the session, as {@link sendBySessionLevel} defines it: a keyed session takes the
+     * level-2 frame, a keyless one — a standalone camera, which never negotiates a key — the same body
+     * sealed level-1. Both are replayed {@link DIRECT_CMD_SENDS}× at 200ms, as every other unacknowledged
+     * control here is.
      */
     rebootStation(sn: string): Promise<void>;
     /**

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

@@ -103,6 +103,9 @@ export declare class LiveStream extends EventEmitter {
     private lastCodec;
     /** Rebuilds an access unit the station split across several frames — see {@link AccessUnitAssembler}. */
     private readonly units;
+    /** Whether a missing video datagram or incomplete unit invalidated the current reference chain. */
+    private awaitingKeyframeAfterGap;
+    private readonly videoGapHandler;
     /** The channel inbound media must be tagged with, once {@link acceptsMedia} trusts the station's tag. */
     private mediaChannel?;
     private tracedFirstVideoCommand;

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

@@ -277,8 +277,8 @@ export declare class P2PSession extends EventEmitter {
     private decryptLevel2;
     get isConnected(): boolean;
     /**
-     * Ask the OS for {@link RECEIVE_BUFFER_BYTES} on a bound socket, and warn once per session when it grants
-     * less or refuses.
+     * Ask the OS for {@link RECEIVE_BUFFER_BYTES} on a bound socket, and log once per session when it grants
+     * less (debug) or refuses (warn).
      *
      * The request is made here rather than through `createSocket`'s `recvBufferSize`: Node applies that option
      * inside the bind callback, where a refusal is thrown out of reach of this session and ends the process.
@@ -435,6 +435,11 @@ export declare class P2PSession extends EventEmitter {
      * "direct" commands (e.g. CAMERA_SWITCH 1035) carry a binary struct, not JSON.
      */
     sendRawLevel2Bytes(payload: Buffer, channel: number, outerCmd?: number, signCode?: number): boolean;
+    /**
+     * The level-1 twin of {@link sendRawLevel2Bytes}: the plaintext `payload` sealed AES-128-ECB under the
+     * level-1 key, signCode 1 — the seal of the level-1 media start. Returns `false` when not connected.
+     */
+    sendRawLevel1Bytes(payload: Buffer, channel: number, outerCmd: number): boolean;
     /**
      * Stop the realtime media stream (`CMD_STOP_REALTIME_MEDIA`, 1004) on a camera `channel`, in the shape
      * its runtime topology takes, as {@link startLiveMedia} selects its start:

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

@@ -144,9 +144,10 @@ export declare class AccessUnitAssembler {
      * `decode` extracts the payload of a frame, whatever the stream's encryption: it is called for EVERY
      * frame, including a continuation, because a continuation carries its own wrapped key ahead of its share
      * of the payload (measured: 129 bytes beyond what its header declares, exactly as a unit's first frame
-     * carries).
+     * carries). A continuation without its matching open unit has no Annex-B start code and cannot be emitted
+     * as a complete unit, even if its repeated header says keyframe.
      */
     push(payload: Buffer, decode: (payload: Buffer) => Buffer | undefined): AssembledAccessUnit[];
     /** Forget an incomplete unit, counting and reporting it. */
-    private discard;
+    discard(): void;
 }

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

@@ -0,0 +1,72 @@
+/**
+ * RTC command router: drives a **HomeBase S1 Pro (T9000)** over the portal's WebRTC data channel instead
+ * of P2P.
+ *
+ * The T9000 answers no P2P lookup, but it accepts the portal's control channel: sign → WS join → scall →
+ * SDP answer → ICE over the relay the hub grants → DTLS → SCTP data channels, with commands riding
+ * `WebrtcDataChannel` as portal packets (see {@link buildPortalPacket}).
+ *
+ * `set-payload` rides the `1350` SET_PAYLOAD envelope, inner `{account_id, cmd, mValue3, payload}`;
+ * `set-json` rides the `1700` CONTROL_PAYLOAD envelope, inner `{account_id, cmd, commandType, data}`.
+ * A command to the station goes on the station channel `255`; an attached device's command shares the
+ * station's session and keeps the device's channel. Other command kinds are refused.
+ *
+ * One session per station, reused across commands and closed after {@link IDLE_CLOSE_MS} without one.
+ * Sends on a session are serialised; an ACK is correlated by its outer command and segment, since it
+ * carries no inner command. An ACK is not an observation of the resulting state.
+ */
+import type { Command } from "../../core/contracts.js";
+import type { Logger } from "../../core/logger.js";
+import { RtcSession, type RtcSessionOptions } from "./session.js";
+export interface RtcIdentity {
+    authToken: string;
+    userId: string;
+    /** The `gtoken` header value the mega session's authed HTTP calls carry. */
+    gtoken: string;
+}
+/** Where a command goes: the station's session, and whether it addresses the station or a device on it. */
+export interface RtcRoute {
+    stationSn: string;
+    /**
+     * The station's `member.admin_user_id`, the account the session and the payload name; the logged-in
+     * user when the station's record carries none.
+     */
+    adminUserId?: string;
+    /** True for a device attached to the station, which keeps the command's own channel. */
+    attached: boolean;
+}
+export interface RtcCommandRouterDeps {
+    /** The logged-in session's credentials; `undefined` while logged out. */
+    identity: () => RtcIdentity | undefined;
+    /** The mega shard the account signs on (`"ie-pr"`, `"eu-pr"`, `"us-pr"`); picks the smart host. */
+    shard: () => string;
+    /** ISO country sent on the sign request (default `US`). */
+    country?: string;
+    logger?: Logger;
+    onError?: (e: Error) => void;
+    createSession?: (opts: RtcSessionOptions) => RtcSession;
+}
+export declare class RtcCommandRouter {
+    private readonly deps;
+    private readonly sessions;
+    constructor(deps: RtcCommandRouterDeps);
+    dispatchCommand(route: RtcRoute, cmd: Command): Promise<void>;
+    /** Tear down every station session (logout / shutdown). */
+    close(): void;
+    /**
+     * Completes on the command ACK or a correlated control-result notification. The notification must
+     * match the request channel, parameter and segment and contain a structured payload. Receipt does
+     * not establish physical actuation. The command is sent once, bounded by {@link ACK_TIMEOUT_MS}.
+     */
+    private sendAwaitAck;
+    private stationSession;
+    /**
+     * 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, or
+     * {@link CONNECT_TIMEOUT_MS} passes. A single promise, so an early failure cannot leave a second one
+     * rejecting unheard.
+     */
+    private bringUp;
+    private touch;
+    private drop;
+}

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

@@ -0,0 +1,93 @@
+/**
+ * The WebRTC peer for a T9000 session: libdatachannel through `node-datachannel`, driven the way the
+ * portal drives a browser's RTCPeerConnection.
+ *
+ * The hub is the offerer: it sends its SDP once it has granted the session, and the peer answers. Six
+ * data channels are declared in the portal's order (`WebrtcDataChannel` first, the command channel,
+ * then audio, idr, video, notify, download). Every one carries PTCS-framed portal packets; which logical
+ * channel a reassembled frame belongs to is the PTCS header's channel, not the data channel it rode on.
+ *
+ * ICE is relay-only. The hub grants a TURN allocation in its `scall 100` reply and completes DTLS only
+ * over the relay pair; on a host pair ICE connects and the DTLS handshake never completes. The peer
+ * plays the DTLS client (`active`) and opens its channels on the client's even SCTP stream ids, which
+ * is what the hub pairs with.
+ *
+ * The native peer is injectable.
+ */
+import { EventEmitter } from "node:events";
+import type { PeerConnection, RtcConfig } from "node-datachannel";
+import { type Logger } from "../../core/logger.js";
+export interface TurnConfig {
+    turn_addr: string;
+    turn_port: number;
+    turn_user: string;
+    turn_password: string;
+    alt_turn_addr?: string;
+    alt_turn_port?: number;
+}
+export type NativePeerFactory = (name: string, config: RtcConfig) => PeerConnection;
+export interface RtcPeerOptions {
+    createPeer?: NativePeerFactory;
+    logger?: Logger;
+}
+export interface RtcPeerEvents {
+    commandChannelOpen: [];
+    /** The command channel went away while the peer itself may still be up. */
+    commandChannelClosed: [];
+    data: [frame: Buffer, linkType: number];
+    iceCandidate: [candidate: string];
+    iceGatheringComplete: [];
+    connectionState: [state: string];
+    error: [err: Error];
+}
+/** The portal's channel list; index 0 is the command channel. */
+export declare const DATA_CHANNEL_LABELS: readonly ["WebrtcDataChannel", "audio", "idr", "video", "notify", "download"];
+export declare const COMMAND_CHANNEL: "WebrtcDataChannel";
+export declare class RtcPeer extends EventEmitter<RtcPeerEvents> {
+    private readonly opts;
+    private pc?;
+    private readonly channels;
+    private framer?;
+    private readonly wireTally;
+    private commandOpen;
+    private remoteSet;
+    private handlingOffer;
+    private channelsCreated;
+    private gatheringDone;
+    /** Set by the framer's wire callback when the native channel refused a packet mid-send. */
+    private wireSendFailed;
+    private readonly pending;
+    private localAnswer?;
+    private readonly logger;
+    constructor(opts?: RtcPeerOptions);
+    /** Create the native peer on the relay the hub granted in `scall 100`. */
+    init(turn: TurnConfig): Promise<void>;
+    /**
+     * The hub offered: apply the offer, declare the channels, return the answer SDP to signal back.
+     *
+     * The offer is pinned to `passive` before it is applied, so the native peer has one legal answer,
+     * `active`: the role is fixed where it is decided, since rewriting the answer afterwards would change
+     * 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.
+     */
+    handleRemoteOffer(offerSdp: string): Promise<string>;
+    addRemoteCandidate(candidate: string): void;
+    /**
+     * Send one portal packet on the command channel, through the framer. False when the channel is not
+     * usable or the native send refused a wire packet, so a dropped frame does not read as success.
+     */
+    sendCommand(portalPacket: Buffer): boolean;
+    /** Tear the peer down. A pending answer is rejected, so a `handleRemoteOffer` in flight settles. */
+    close(): void;
+    private acceptsCandidate;
+    private createChannels;
+    /**
+     * Wire one data channel. Every channel feeds the framer once the command channel has opened it; a
+     * message before that has nothing to reassemble into and is dropped.
+     */
+    private wireChannel;
+    private addNow;
+    private flushPending;
+}

package/dist/transport/rtc/portal-packet.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The command framing a HomeBase S1 Pro (T9000) speaks over its WebRTC data channel — the wire the
+ * security.eufy.com web client builds, reproduced byte-exact.
+ *
+ * A packet is a 16-byte header behind the ASCII magic `XZYH`, then a JSON body, sent in the clear (the
+ * DTLS channel is the encryption). Replies come back with `isResponse = 1`, the same `segment` the
+ * request carried, and a body whose first four bytes are a little-endian result code.
+ *
+ * Every offset is the portal bundle's header builder and parser (`Gr()` / `Qr()`) and its
+ * `worker_sctp_send`.
+ */
+export declare const PORTAL_HEADER_LENGTH = 16;
+/** Portal link types — which logical channel a frame belongs to (`worker_sctp_send`). */
+export declare const PortalLinkType: {
+    /** Command channel: requests out, acknowledgements back. */
+    readonly COMMAND: 1;
+    /** Station-originated frames: pushes, notify payloads, control results. */
+    readonly NOTIFY: 3;
+};
+export interface PortalHeader {
+    commandId: number;
+    paramLength: number;
+    segment: number;
+    channel: number;
+    isResponse: number;
+    devType: number;
+}
+export interface PortalRequest {
+    commandId: number;
+    channel: number;
+    /** 1..255, wraps; echoed by the reply so it can be matched. */
+    segment: number;
+    payload: Record<string, unknown>;
+    isResponse?: number;
+    devType?: number;
+}
+export interface PortalResponse {
+    commandId: number;
+    channel: number;
+    segment: number;
+    isResponse: number;
+    linkType: number;
+    /** Command-channel replies only: the int32 result code (0 = ok). */
+    errCode?: number;
+    /** Notify frames: the nested `cmd` the JSON body carries. */
+    cmd?: number;
+    data?: unknown;
+}
+/** The 16-byte header (portal `Gr()`). */
+export declare function buildPortalHeader(commandId: number, paramLength: number, channel: number, segment: number, isResponse?: number, devType?: number): Buffer;
+/** Parse the header (portal `Qr()`); `undefined` when the magic is missing or the buffer is short. */
+export declare function parsePortalHeader(buf: Buffer): PortalHeader | undefined;
+/** Whether a buffer starts a portal packet. */
+export declare function isPortalPacket(buf: Buffer): boolean;
+/** A complete request packet: header + body. */
+export declare function buildPortalPacket(req: PortalRequest): Buffer;
+/**
+ * Parse an inbound packet. On the command channel the body opens with the int32 result code and may
+ * carry JSON after it; on the notify channel the whole body is JSON with a nested `cmd`.
+ */
+export declare function parsePortalPacket(buf: Buffer, linkType?: number): PortalResponse | undefined;
+/** A 1..255 segment counter that never yields 0 (the portal reserves it). */
+export declare class SegmentCounter {
+    private current;
+    next(): number;
+}

package/dist/transport/rtc/ptcs-framer.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The PTCS packetiser: a clean-room implementation of the framing the portal wraps around every portal
+ * packet on `WebrtcDataChannel` (the portal's `libsctp` module). Nothing of that module ships here.
+ *
+ * Every wire packet is the same size, `28 + payload bytes`, zero-padded. The size is carried per packet,
+ * so the receiver accepts any:
+ *
+ *   0   "PTCS"
+ *   4   u8   3              constant
+ *   5   u8   channel        the logical channel the frame belongs to: 0 command, 2 notify
+ *   6   u16  sequence       a frame counter: every packet of a frame carries the same value, and it
+ *                           steps once per frame
+ *   8   u32  frame id       one value per frame, shared by all its packets — the portal uses a ms clock
+ *   12  u32  frame length   total bytes of the frame
+ *   16  u16  packet index   0-based position of this packet in the frame
+ *   18  u16  0x4000 | (last ? 0x0400 : 0) | payload length      (payload ≤ 1023 fits the low bits)
+ *   20  8 × 0
+ *   28  payload             `payload length` bytes, then zeros to the packet size
+ *
+ * The format carries no forward error correction. The receiver completes a frame only when every index
+ * up to the `last` one is present and their lengths add up; frames whose packets stop arriving are
+ * dropped after {@link PTCS_STALE_MS}.
+ */
+export declare const PTCS_HEADER_LENGTH = 28;
+/** The portal's packet payload size: 1028-byte packets, 1000 bytes of payload after the header. */
+export declare const PTCS_DEFAULT_PAYLOAD_BYTES = 1000;
+/** SCTP channel ids as the portal numbers them, and the link type each maps to on receive. */
+export declare const PtcsChannel: {
+    readonly COMMAND: 0;
+    readonly NOTIFY: 2;
+};
+/** The link type a received frame belongs to: notify on the notify channel, command otherwise. */
+export declare function linkTypeForChannel(channel: number): number;
+/** How long a partly received frame is kept before it is dropped. */
+export declare const PTCS_STALE_MS = 15000;
+export interface PtcsHeader {
+    channel: number;
+    /** The sender's running packet counter — see the header map. */
+    sequence: number;
+    frameId: number;
+    frameLength: number;
+    index: number;
+    last: boolean;
+    payloadLength: number;
+}
+export declare function parsePtcsHeader(packet: Buffer): PtcsHeader | undefined;
+/** Split one frame into wire packets. */
+export declare function packetize(frame: Buffer, opts: {
+    channel?: number;
+    frameId: number;
+    payloadBytes?: number;
+    sequence?: number;
+}): Buffer[];
+/** Reassemble frames from wire packets, in any order, one frame at a time per (channel, id). */
+export declare class PtcsReassembler {
+    private readonly onFrame;
+    private readonly now;
+    private readonly partials;
+    constructor(onFrame: (frame: Buffer, channel: number) => void, now?: () => number);
+    push(packet: Buffer): boolean;
+    /** Drop frames that stopped arriving; call periodically. */
+    expire(): void;
+}
+/** Frame ids the way the portal draws them — a millisecond clock, nudged forward on a collision. */
+export declare function frameIdClock(now?: () => number): () => number;
+/**
+ * The framer between portal packets and the data channel: PTCS out, PTCS in, with the portal's channel
+ * mapping. An inbound bare `XZYH` packet, which the hub sometimes answers with, passes through as a
+ * command frame. Frame ids are a millisecond clock and the frame counter starts at 0.
+ */
+export declare class PtcsFramer {
+    private onWire?;
+    private onFrame?;
+    private reassembler?;
+    private sweep?;
+    private ready;
+    private readonly nextFrameId;
+    private sequence;
+    /** Arm the two callbacks; `sendFrame` may be called from here on. */
+    init(onWirePacket: (packet: Buffer) => void, onFrame: (frame: Buffer, linkType: number) => void): void;
+    isReady(): boolean;
+    sendFrame(portalPacket: Buffer): void;
+    recvPacket(wirePacket: Buffer): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * The T9000's signalling does not carry SDP text: an `info` message carries a small JSON — DTLS setup
+ * role, ICE ufrag/pwd, fingerprint and candidates — and each side rebuilds the one-m-line SDP from it.
+ * This is the portal's own translation (security.eufy.com): the SDP handed to the native peer is the one
+ * the hub meant, and the JSON sent back is the one the hub parses.
+ */
+export interface ScallSdpJson {
+    setup?: string;
+    ice?: {
+        ufrag?: string;
+        pwd?: string;
+        fingerprint_type?: string;
+        fingerprint?: string;
+    };
+    candidate?: string[];
+}
+/** The hub's SDP is one SCTP application m-line bundled under mid 2, as the portal template has it. */
+export declare const HUB_SDP_MID = "2";
+/** The max message size the hub advertises; the answer carries the same. */
+export declare const ANKER_MAX_MESSAGE_SIZE = 262144;
+/**
+ * Rebuild the hub's offer (or answer) SDP from its scall JSON. The JSON carries the fingerprint as bare
+ * hex; the SDP gets colon-separated byte pairs.
+ */
+export declare function scallJsonToSdp(json: ScallSdpJson, now?: () => number): string;
+/** Reduce our local SDP to the JSON the hub parses. `actpass` is left out: the hub wants a concrete role. */
+export declare function sdpToScallJson(sdp: string): ScallSdpJson;
+/** The candidate type (`host` / `srflx` / `relay`) named inside an ICE candidate line. */
+export declare function iceCandidateType(candidate: string): string;
+/** Pin `a=max-message-size` to what the hub advertises, whatever libdatachannel wrote. */
+export declare function pinMaxMessageSize(sdp: string): string;
+/**
+ * Force a concrete DTLS role into an SDP. The hub offers `actpass`; the peer pins that offer to
+ * `passive`, which leaves one legal answer, `active`. The DTLS client opens its data channels on the
+ * even SCTP stream ids (RFC 8832), and the hub pairs with those: its command channel is stream 0.
+ */
+export declare function forceDtlsRole(sdp: string, role: "active" | "passive"): string;
+/**
+ * The wire form of a trickled ICE candidate: `candidate:...`, the attribute's value, which is the shape
+ * the hub sends and parses. The native peer hands out the SDP attribute line (`a=candidate:...`).
+ */
+export declare function toWireCandidate(candidate: string): string;

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

@@ -0,0 +1,78 @@
+/**
+ * One T9000 command session end to end: sign → signalling socket → `scall` → the hub's SDP offer →
+ * our answer → ICE → DTLS → the command data channel open.
+ *
+ * The signalling exchange, as the portal runs it and as confirmed live:
+ *
+ *   → scall                          (action 3, channel 0, the hub's own session)
+ *   ← scall {status: 100, turn}      the hub granted the session and handed out TURN credentials
+ *   ← info  {sdp | format:"SDP"}     the hub's offer, as scall JSON
+ *   → info  {sdp}                    the answer
+ *   ↔ info  {candidate}              trickle ICE on the same channel; "" ends it
+ *   ← scall {status: 200}            → ack
+ *   ← scall {status: 486 | 408}      busy / timeout: the session fails
+ *   ← hangup                         the hub ended it
+ *
+ * The command data channel is the session: `close` fires once, when the channel closes, the peer fails,
+ * the signalling socket drops or {@link RtcSession.close} is called, even while the peer connection is
+ * nominally up.
+ *
+ * Both the signalling client and the peer are injectable.
+ */
+import { EventEmitter } from "node:events";
+import { RtcPeer, type RtcPeerOptions } from "./peer.js";
+import { RtcSignalingClient, type RtcSignalingOptions } from "./signaling.js";
+export interface RtcSessionOptions extends RtcSignalingOptions {
+    peer?: RtcPeerOptions;
+    createSignaling?: (opts: RtcSignalingOptions) => RtcSignalingClient;
+    createPeer?: (opts: RtcPeerOptions) => RtcPeer;
+}
+export interface RtcSessionEvents {
+    connected: [];
+    close: [];
+    error: [err: Error];
+    /** A reassembled frame: portal packet bytes + the link type it arrived on. */
+    commandData: [frame: Buffer, linkType: number];
+}
+export declare class RtcSession extends EventEmitter<RtcSessionEvents> {
+    private readonly opts;
+    private readonly signaling;
+    private readonly peer;
+    private readonly logger;
+    private turn?;
+    private authOk;
+    private authWaiter?;
+    private connected;
+    private closed;
+    private closeAnnounced;
+    private sdpHandled;
+    private chain;
+    constructor(opts: RtcSessionOptions);
+    get isConnected(): boolean;
+    /**
+     * Start the sequence; resolves once `scall` 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
+     * placing the call.
+     */
+    connect(): Promise<void>;
+    /** Send one portal packet; false when the command channel isn't open. */
+    sendCommand(portalPacket: Buffer): boolean;
+    /**
+     * Hang up and tear both sides down; `close` fires once, here if nothing announced it before. A
+     * `connect()` still waiting for the signalling auth is rejected and its timer stopped.
+     */
+    close(): void;
+    private announceClose;
+    private waitForAuth;
+    /** Settle a pending auth wait: resolve it, or reject it with `err`; either way its timer stops. */
+    private settleAuth;
+    private onSignaling;
+    /** A `scall` status: `100` grants the relay, `200` is acknowledged, `486`/`408` fail the session. */
+    private onCall;
+    /**
+     * An `info`: trickle ICE, in either of the two shapes the hub sends, or the hub's SDP offer. The offer
+     * is answered only once a TURN grant is in: the peer is relay-only, so an offer ahead of `scall 100`
+     * is reported and left unanswered.
+     */
+    private onInfo;
+}