@mega-yfue/eufy-sdk 0.5.0-beta.21 → 0.5.0-beta.22

package/dist/client/eufy-mega.d.ts

@@ -418,9 +418,10 @@ export declare class EufyMega extends EventEmitter {
      * 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. A T9000
+     * 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. Everything else is P2P.
+     * 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. Everything else is P2P.
      */
     private routeCommand;
     /**

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;
     /**

package/dist/index.js

@@ -3068,8 +3068,7 @@ var STATION_TYPES = /* @__PURE__ */ new Set([
   DeviceType.STATION_9000,
   DeviceType.MINIBASE_CHIME,
   DeviceType.HOMEBASE_MINI,
-  DeviceType.NVR_S4_MAX,
-  DeviceType.CAMERA_POE_S4
+  DeviceType.NVR_S4_MAX
 ]);
 var LOCK_TYPES = /* @__PURE__ */ new Set([
   DeviceType.LOCK_BLE,
@@ -3143,7 +3142,7 @@ function codecFromModel(model) {
     return "vacuum";
   if (/^T8(00[0-9]|010|023|025|030)/.test(m))
     return "station";
-  if (/^T8N0/.test(m) || /^T8E0/.test(m))
+  if (/^T8N0/.test(m))
     return "station";
   if (/^T9000/.test(m))
     return "station";
@@ -5095,6 +5094,7 @@ var isIndoorCamMini = (ctx) => ctx.deviceType === DeviceType.INDOOR_COST_DOWN_CA
 var isIndoorPanTiltS350 = (ctx) => has(INDOOR_PT_S350_TYPES, ctx.deviceType);
 var isHomeBase = (ctx) => has(HOMEBASE_TYPES, ctx.deviceType);
 var isStation9000 = (ctx) => ctx.deviceType === DeviceType.STATION_9000;
+var isNvrT8N00 = (ctx) => ctx.model === "T8N00";
 var isAiotVacuum = (ctx) => ctx.category !== "eufy_home_tuya";
 var isTuyaVacuum = (ctx) => ctx.category === "eufy_home_tuya";
 
@@ -7683,7 +7683,8 @@ var ARMING_CMD = {
    */
   SET_ARMING: 1224,
   /**
-   * The per-mode alarm/arm-delay configuration write. ✅ WIRE CAPTURED live on a T8030 (
+   * One guard mode's per-device action table (app `CMD_SET_ALL_ACTION`), which carries the alarm delays
+   * and each device's actions in that mode. ✅ WIRE CAPTURED live on a T8030 (
    * 2026-07-23, both directions): a **bare
    * JSON frame, no `1350`/`1700` envelope** — outer P2P cmd IS `1255` itself, station channel 255,
    * plaintext `{account_id, count_down_alarm:{channel_list,delay_time},
@@ -7700,15 +7701,26 @@ var ARMING_CMD = {
    * corresponding GET command (`1310`/inner cmd `40003`, sent by the app right before editing) always
    * replied `{count:0,data:null}` in every capture — genuinely empty, not a decrypt failure (confirmed
    * via the same bidirectional decrypt this finding used) — so the app does NOT read the current
-   * config this way; how it does is still unknown. Without a working GET, safely PATCHING just one
-   * channel in or out of an existing list isn't possible without risking clobbering the rest — so
+   * config this way; a T8010 reports it on its own params instead, see below. Without a working GET,
+   * safely PATCHING just one channel in or out of an existing list isn't possible without risking
+   * clobbering the rest — so
    * this ships as a caller-supplies-everything write instead of guessing a merge.
    * `devices`/`siren_sensor_action` are even less understood (raw per-device action codes, meaning
    * unconfirmed) and MUST come from a value independently read/captured for the target mode —
    * see `AlarmDelayConfig`'s field docs.
+   *
+   * ✅ On a T8010 the app writes the same command for the Device Control screen: header channel 0, the
+   * whole table of the mode `{mode_id, devices, count_down_alarm, count_down_arm}`, acked by an all-zero
+   * 1255 reply. The T8010 reports each table on its own params, Home on 1157 and Away on 1158, and the
+   * reported table follows a write within 15 s. See {@link DEVICE_NOTIFY_FLAG}.
    */
-  ALARM_DELAY_CONFIG: 1255
+  SET_ALL_ACTION: 1255
 };
+var DEVICE_NOTIFY_FLAG = 8;
+function actionTable(read, mode) {
+  const value = read(`${mode}ActionTable`)?.value;
+  return value && typeof value === "object" && Array.isArray(value.devices) ? value : void 0;
+}
 var ARMING_MODE_WIRE = {
   away: 0,
   home: 1,
@@ -7745,7 +7757,15 @@ function alarmDelayCommand(mode, config, ctx) {
     devices: config.devices.map((d) => ({ action: d.action, device_channel: d.deviceChannel })),
     siren_sensor_action: config.sirenSensorAction.map((d) => ({ action: d.action, device_channel: d.deviceChannel }))
   };
-  return setJsonRaw(ARMING_CMD.ALARM_DELAY_CONFIG, data, ctx, STATION_CHANNEL2);
+  return setJsonRaw(ARMING_CMD.SET_ALL_ACTION, data, ctx, STATION_CHANNEL2);
+}
+var ACTION_TABLE_LAG_MS = 15e3;
+function withDeviceNotification(table, channel, on) {
+  if (!table?.devices.some((d) => d.device_channel === channel))
+    return void 0;
+  const { account_id: _account, ...rest } = table;
+  const devices = table.devices.map((d) => d.device_channel === channel ? { ...d, action: on ? d.action | DEVICE_NOTIFY_FLAG : d.action & ~DEVICE_NOTIFY_FLAG } : d);
+  return { ...rest, devices };
 }
 var ARMING_MEMBERS = {
   /**
@@ -7803,7 +7823,45 @@ var ARMING_MEMBERS = {
     } catch (e) {
       return Promise.reject(e);
     }
-  }, "Write the full per-mode alarm/arm-delay configuration.")
+  }, "Write the full per-mode alarm/arm-delay configuration."),
+  /**
+   * Whether the device on `channel` sends a push notification in `mode`: its {@link DEVICE_NOTIFY_FLAG}
+   * in the action table the station reports for that mode. `undefined` where the station reports no table
+   * or the table does not list `channel`. A device's channel is `EufyDevice.channel`.
+   */
+  deviceNotification: method(({ read }) => (mode, channel) => {
+    const action = actionTable(read, mode)?.devices.find((d) => d.device_channel === channel)?.action;
+    return typeof action === "number" ? (action & DEVICE_NOTIFY_FLAG) !== 0 : void 0;
+  }, "Whether the device on a channel sends a push notification in a guard mode (home/away).", (ctx) => ctx.model === "T8010"),
+  /**
+   * Turn the push notification of the device on `channel` on or off in `mode` (cmd
+   * {@link ARMING_CMD.SET_ALL_ACTION}): the station's reported table written back with that one flag
+   * changed. Rejects, sending nothing, where the table does not list `channel`. A write builds on the last
+   * one sent for that mode until the station reports a table observed 15 s after it, so a second write does
+   * not revert it; a write whose dispatch rejects is not built on.
+   */
+  setDeviceNotification: method(({ ctx, sink, read }) => {
+    const sent = /* @__PURE__ */ new Map();
+    return (mode, channel, on) => {
+      const last = sent.get(mode);
+      const observed = read(`${mode}ActionTable`)?.ts ?? 0;
+      const base = last && observed < last.at + ACTION_TABLE_LAG_MS ? last.table : actionTable(read, mode);
+      const table = withDeviceNotification(base, channel, on);
+      if (!table) {
+        return Promise.reject(new Error(`arming: no ${mode} action table lists channel ${channel} [${describeDevice(ctx)}]`));
+      }
+      sent.set(mode, { table, at: Date.now() });
+      return sink.dispatch(setJsonRaw(ARMING_CMD.SET_ALL_ACTION, table, ctx, 0)).catch((err) => {
+        if (sent.get(mode)?.table === table) {
+          if (last)
+            sent.set(mode, last);
+          else
+            sent.delete(mode);
+        }
+        throw err;
+      });
+    };
+  }, "Turn the push notification of the device on a channel on or off in a guard mode (home/away).", (ctx) => ctx.model === "T8010")
 };
 var ARMING = {
   capability: "arming",
@@ -11439,9 +11497,15 @@ var SECURITY_PARAMS = {
     provenance: "guessed"
   },
   1157: {
-    name: "jsDelayHome",
+    name: "homeActionTable",
     type: "string",
-    provenance: "apk",
+    provenance: "verified",
+    encoding: "base64+json"
+  },
+  1158: {
+    name: "awayActionTable",
+    type: "string",
+    provenance: "verified",
     encoding: "base64+json"
   },
   1159: {
@@ -15367,7 +15431,7 @@ var PADDED_RESULT_BYTES = 132;
 var CMD_CAMERA_INFO = 1103;
 var CMD_DATABASE_IMAGE = 1308;
 var CMD_DATABASE = 1306;
-var DB_QUERY = { FULL_TABLE: 1e4, COMBINATION_WITH_AI: 10011 };
+var DB_QUERY = { FULL_TABLE: 1e4, COMBINATION_WITH_AI: 10011, QUERY_LOCAL: 10017 };
 var GCM_AAD = Buffer.from("eufy security");
 var LEVEL2_SEQ_BASE = 16909056;
 function paramReport(payload) {
@@ -15397,9 +15461,13 @@ function firstTableRows(text2) {
     } catch {
       continue;
     }
-    const data = parsed?.data;
-    if (Array.isArray(data))
-      return data;
+    const reply = parsed;
+    if (typeof reply?.mIntRet === "number" && reply.mIntRet !== 0)
+      return { error: reply.mIntRet };
+    if (reply?.data === "[]")
+      return { rows: [] };
+    if (Array.isArray(reply?.data))
+      return { rows: reply.data };
   }
   return void 0;
 }
@@ -16021,6 +16089,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       socket.removeAllListeners("error");
       socket.on("error", (error) => this.emit("error", error));
       this.socket = socket;
+      this.requestReceiveBuffer(socket);
     }
     this.connected = true;
     this.connectedAtMs = Date.now();
@@ -16759,6 +16828,29 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       query: this.fullTableQuery()
     });
   }
+  /**
+   * Read a date-ranged page of `history_record_info` from the station. The reply's `data` array groups
+   * recording rows with companion tables; each group retains its `table_name` and `payload`.
+   * `startTime` is `"0"` for the newest page or the oldest row's `yyyyMMddHHmmss` cursor for older rows.
+   */
+  queryRecordPage(opts) {
+    return this.readDatabase("history_record_info", {
+      accountId: opts.accountId,
+      innerCmd: DB_QUERY.QUERY_LOCAL,
+      query: {
+        count: opts.count ?? 20,
+        start_date: opts.startDate,
+        end_date: opts.endDate,
+        start_time: opts.startTime ?? "0",
+        event_type: 0,
+        ai_type: 0,
+        storage_cloud: -1,
+        trigger_type: 0,
+        detection_type: 0,
+        flag: 0
+      }
+    });
+  }
   /**
    * Query one on-station table and answer its rows, once the reply is whole.
    *
@@ -16766,7 +16858,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * several frames whose decrypted text is a fragment of one document, so the fragments are
    * accumulated here and scanned after each one. Answers that document's `data` rows. Rejects when
    * `signal` aborts, and when `timeoutMs` (default {@link DB_TABLE_TIMEOUT_MS}) elapses with no
-   * complete reply.
+   * complete reply, and when the station answers a non-zero `mIntRet`.
    *
    * One read at a time per session: while one is accumulating, every {@link queryDatabase} on the
    * session throws, so a second reply cannot land in this buffer.
@@ -16774,16 +16866,22 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   async readDatabase(table, opts = {}) {
     if (opts.signal?.aborted)
       throw new Error("readDatabase: aborted");
-    this.queryDatabase(table, { accountId: opts.accountId, query: this.fullTableQuery() });
+    this.queryDatabase(table, {
+      accountId: opts.accountId,
+      innerCmd: opts.innerCmd,
+      query: opts.query ?? this.fullTableQuery()
+    });
     this.dbReadInFlight = true;
     try {
       return await new Promise((resolve, reject) => {
         let text2 = "";
         const onChunk = (chunk) => {
           text2 += chunk.text;
-          const rows = firstTableRows(text2);
-          if (rows)
-            settle(() => resolve(rows));
+          const result = firstTableRows(text2);
+          if (result?.error !== void 0)
+            settle(() => reject(new Error(`readDatabase: ${table} refused: ${result.error}`)));
+          else if (result?.rows)
+            settle(() => resolve(result.rows));
         };
         const timer = setTimeout(() => settle(() => reject(new Error(`readDatabase: ${this.cfg.stationSn} sent no complete ${table}`))), opts.timeoutMs ?? DB_TABLE_TIMEOUT_MS);
         const onAbort = () => settle(() => reject(new Error("readDatabase: aborted")));
@@ -20844,16 +20942,12 @@ function stationOf(dev) {
   const parent = typeof raw.parent_sn === "string" && raw.parent_sn && raw.parent_sn !== dev.sn ? raw.parent_sn : void 0;
   return parent ?? dev.stationSn ?? resolvedStationSn(raw, dev.sn);
 }
-function statedChannel(dev) {
-  const v = dev.raw?.device_channel;
-  return typeof v === "number" ? v : void 0;
-}
 function stationChannels(devices) {
   const out = /* @__PURE__ */ new Map();
   const claimants = /* @__PURE__ */ new Map();
   for (const d of devices) {
     const station = stationOf(d);
-    const stated = statedChannel(d);
+    const stated = d.channel;
     if (d.sn === station || stated === void 0)
       continue;
     const counts = claimants.get(station) ?? /* @__PURE__ */ new Map();
@@ -20862,7 +20956,7 @@ function stationChannels(devices) {
   }
   for (const d of devices) {
     const station = stationOf(d);
-    const stated = statedChannel(d);
+    const stated = d.channel;
     if (d.sn === station)
       out.set(d.sn, { channel: stated ?? 0 });
     else if (stated === void 0)
@@ -22264,7 +22358,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * **`set-json-raw` intent** — bare JSON, no envelope: outer P2P cmd = `outerCmd` itself, plaintext
    * exactly `{account_id,...data}` (`session.sendRawLevel2` with no wrapper). Reversed from a live
    * capture of the app's own SET_SNOOZE_TIME (1271) frame — see `param-dictionary.ts`'s `1271` entry
-   * (`snoozeTime`); the alarm-delay config (1255, `arming.ts`'s `ARMING_CMD.ALARM_DELAY_CONFIG`) reuses
+   * (`snoozeTime`); the alarm-delay config (1255, `arming.ts`'s `ARMING_CMD.SET_ALL_ACTION`) reuses
    * the same bare-JSON shape.
    */
   async sendJsonRaw(sn, outerCmd, data, channel) {
@@ -22927,6 +23021,7 @@ var RtcPeer = class extends EventEmitter7 {
   wireTally = /* @__PURE__ */ new Map();
   commandOpen = false;
   remoteSet = false;
+  remoteMid = HUB_SDP_MID;
   handlingOffer = false;
   channelsCreated = false;
   gatheringDone = false;
@@ -22947,7 +23042,7 @@ var RtcPeer = class extends EventEmitter7 {
     const createPeer = this.opts.createPeer ?? await loadNativePeerFactory();
     const config = {
       iceServers: turnServers(turn),
-      iceTransportPolicy: "relay",
+      iceTransportPolicy: this.opts.iceTransportPolicy ?? "relay",
       maxMessageSize: ANKER_MAX_MESSAGE_SIZE,
       enableIceTcp: true
     };
@@ -22998,6 +23093,8 @@ var RtcPeer = class extends EventEmitter7 {
     this.handlingOffer = true;
     try {
       const offer = forceDtlsRole(offerSdp, "passive");
+      const application = offer.split(/(?=^m=)/m).find((section) => section.startsWith("m=application "));
+      this.remoteMid = application?.match(/^a=mid:([^\r\n]+)/m)?.[1] ?? HUB_SDP_MID;
       const answerWait = new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
           this.localAnswer = void 0;
@@ -23070,7 +23167,7 @@ var RtcPeer = class extends EventEmitter7 {
     this.pending.length = 0;
   }
   acceptsCandidate(candidate) {
-    return iceCandidateType(candidate) === "relay";
+    return this.opts.iceTransportPolicy === "all" || iceCandidateType(candidate) === "relay";
   }
   createChannels() {
     if (!this.pc || this.channelsCreated)
@@ -23126,7 +23223,7 @@ var RtcPeer = class extends EventEmitter7 {
   }
   addNow(candidate) {
     try {
-      this.pc?.addRemoteCandidate(candidate, HUB_SDP_MID);
+      this.pc?.addRemoteCandidate(candidate, this.remoteMid);
     } catch (e) {
       this.logger.warn(`[rtc] addRemoteCandidate failed: ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -23303,14 +23400,14 @@ var RtcSignalingClient = class extends EventEmitter8 {
     this.sendEnvelope(`${this.opts.authToken}_${this.makeMsgId()}`, inner);
   }
   sendCall() {
-    this.sendSession("scall");
+    this.sendSession(this.opts.signalingMode ?? "scall");
   }
   sendAck() {
     this.sendSession("ack");
   }
-  /** The SDP answer, as scall JSON text, in an `info`. */
-  sendInfoSdp(scallJson) {
-    this.sendSession("info", { sdp: scallJson });
+  /** The SDP answer, encoded for the negotiated call format, in an `info`. */
+  sendInfoSdp(sdp) {
+    this.sendSession("info", { sdp });
   }
   /** Trickle a candidate on the session's channel, like its SDP answer. An empty candidate ends them. */
   sendInfoCandidate(candidate) {
@@ -23438,7 +23535,7 @@ var RtcSession = class extends EventEmitter9 {
     return this.connected;
   }
   /**
-   * Start the sequence; resolves once `scall` is sent. `connected` fires when the channel opens. A session
+   * Start the sequence; resolves once the call 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.
    */
@@ -23450,7 +23547,7 @@ var RtcSession = class extends EventEmitter9 {
     await this.waitForAuth();
     if (this.closed)
       throw new Error("RTC session closed before the call was placed");
-    this.logger.debug(`[rtc] ${this.opts.stationSn} authenticated \u2014 scall`);
+    this.logger.debug(`[rtc] ${this.opts.stationSn} authenticated \u2014 ${this.opts.signalingMode ?? "scall"}`);
     this.signaling.sendCall();
   }
   /** Send one portal packet; false when the command channel isn't open. */
@@ -23587,7 +23684,7 @@ var RtcSession = class extends EventEmitter9 {
       offer = sdpText;
     }
     const answer = await this.peer.handleRemoteOffer(offer);
-    this.signaling.sendInfoSdp(JSON.stringify(sdpToScallJson(answer)));
+    this.signaling.sendInfoSdp(this.opts.signalingMode === "call" ? answer : JSON.stringify(sdpToScallJson(answer)));
     this.logger.debug(`[rtc] ${this.opts.stationSn} answered the hub's offer`);
   }
 };
@@ -23608,7 +23705,7 @@ var RtcCommandRouter = class {
   }
   async dispatchCommand(route, cmd) {
     if (cmd.kind !== "set-payload" && cmd.kind !== "set-json") {
-      throw new Error(`rtc: ${cmd.kind} is not routable over the T9000 control channel (only set-payload or set-json)`);
+      throw new Error(`rtc: ${cmd.kind} is not routable over the RTC control channel (only set-payload or set-json)`);
     }
     const identity = this.deps.identity();
     if (!identity)
@@ -23616,7 +23713,7 @@ var RtcCommandRouter = class {
     const { stationSn } = route;
     const adminUserId = route.adminUserId || identity.userId;
     const channel = route.attached ? cmd.channel : PORTAL_STATION_CHANNEL;
-    const st = await this.stationSession(stationSn, adminUserId, identity);
+    const st = await this.stationSession(route, adminUserId, identity);
     const outerCmd = cmd.kind === "set-json" ? PORTAL_CMD_CONTROL_PAYLOAD : PORTAL_CMD_SET_PAYLOAD;
     const innerCmd = cmd.kind === "set-json" ? cmd.param : cmd.cmd;
     const payload = cmd.kind === "set-json" ? { account_id: adminUserId, cmd: cmd.param, commandType: cmd.param, data: cmd.data } : { account_id: adminUserId, cmd: cmd.cmd, mValue3: cmd.mValue3 ?? 0, payload: cmd.payload };
@@ -23677,7 +23774,8 @@ var RtcCommandRouter = class {
       }
     });
   }
-  async stationSession(sn, adminUserId, identity) {
+  async stationSession(route, adminUserId, identity) {
+    const sn = route.stationSn;
     const existing = this.sessions.get(sn);
     if (existing) {
       await existing.ready;
@@ -23695,7 +23793,8 @@ var RtcCommandRouter = class {
       shard: this.deps.shard(),
       country: this.deps.country ?? "US",
       logger: this.deps.logger,
-      peer: { logger: this.deps.logger }
+      signalingMode: route.signalingMode,
+      peer: { logger: this.deps.logger, iceTransportPolicy: route.iceTransportPolicy }
     });
     const ready = this.bringUp(sn, session);
     const st = { session, seg: new SegmentCounter(), ready, queue: Promise.resolve() };
@@ -26556,6 +26655,7 @@ var DeviceRegistry = class {
           name: recordName(raw, deviceClass),
           model: raw.device_model,
           stationSn: resolvedStationSn(raw, raw.device_sn),
+          ...typeof raw.device_channel === "number" ? { channel: raw.device_channel } : {},
           p2pDid: raw.p2p_did,
           params,
           paramUpdatedAt,
@@ -27908,9 +28008,10 @@ var EufyMega = class extends EventEmitter12 {
    * 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. A T9000
+   * 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. Everything else is P2P.
+   * 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. Everything else is P2P.
    */
   routeCommand(sn, cmd) {
     if (cmd.kind === "ff09-actuate" || cmd.kind === "ff09-autolock" || cmd.kind === "ff09-setting-toggle") {
@@ -27936,13 +28037,16 @@ var EufyMega = class extends EventEmitter12 {
     const station = devices.find((d) => d.sn === stationSn);
     const stationRaw = station?.raw ?? {};
     const deviceType = typeof stationRaw.device_type === "number" ? stationRaw.device_type : void 0;
-    if (target && station && isStation9000({ deviceType, model: station.model })) {
+    const family = { deviceType, model: station?.model };
+    const native = isNvrT8N00(family);
+    if (target && station && (isStation9000(family) || native)) {
       const attached = stationSn !== sn;
       if (attached && this.registry.serialForFrame(stationSn, cmd.channel) !== sn)
         return Promise.reject(new Error("RTC command requires an unambiguous attached-device channel"));
       const member = stationRaw.member?.admin_user_id;
       const adminUserId = typeof member === "string" && member ? member : void 0;
-      return this.rtc.dispatchCommand({ stationSn, adminUserId, attached }, cmd);
+      const base = { stationSn, adminUserId, attached };
+      return this.rtc.dispatchCommand(native ? { ...base, signalingMode: "call", iceTransportPolicy: "all" } : base, cmd);
     }
     return this.p2p.dispatchCommand(sn, cmd);
   }