@mega-yfue/eufy-sdk 0.5.0-beta.93 → 0.5.0-beta.95

package/dist/index.js

@@ -15193,6 +15193,8 @@ __export(codec_exports, {
   buildLookupWithKeyPayload: () => buildLookupWithKeyPayload,
   buildLookupWithKeyPayload2: () => buildLookupWithKeyPayload2,
   buildRawCommandPayload: () => buildRawCommandPayload,
+  buildRelayPacketPayload: () => buildRelayPacketPayload,
+  buildRelayRequestPayload: () => buildRelayRequestPayload,
   buildStringCommandPayload: () => buildStringCommandPayload,
   buildStringPairCommandPayload: () => buildStringPairCommandPayload,
   buildVoidCommandPayload: () => buildVoidCommandPayload,
@@ -15211,6 +15213,9 @@ __export(codec_exports, {
   paddingP2PData: () => paddingP2PData,
   parseDataFrameHeader: () => parseDataFrameHeader,
   parseLookupAddr: () => parseLookupAddr,
+  parseRelayList: () => parseRelayList,
+  parseRelayPortAck: () => parseRelayPortAck,
+  parseRelayTo: () => parseRelayTo,
   readNullTerminatedString: () => readNullTerminatedString,
   stringWithLength: () => stringWithLength
 });
@@ -15219,7 +15224,12 @@ var MAGIC_WORD = "XZYH";
 var RequestMessageType = {
   LOCAL_LOOKUP: Buffer.from([241, 48]),
   LOOKUP_WITH_KEY: Buffer.from([241, 38]),
+  /** `ListReq_DSK`: the same body as a variant-2 lookup, answered with {@link ResponseMessageType.LIST_REQ_ACK}. */
   LOOKUP_WITH_KEY2: Buffer.from([241, 106]),
+  RLY_HELLO: Buffer.from([241, 112]),
+  RLY_PORT: Buffer.from([241, 114]),
+  RLY_REQ: Buffer.from([241, 128]),
+  RLY_PKT: Buffer.from([241, 131]),
   CHECK_CAM: Buffer.from([241, 65]),
   CHECK_CAM2: Buffer.from([241, 66]),
   PING: Buffer.from([241, 224]),
@@ -15231,14 +15241,24 @@ var RequestMessageType = {
 var ResponseMessageType = {
   LOCAL_LOOKUP_RESP: Buffer.from([241, 65]),
   LOOKUP_ADDR: Buffer.from([241, 64]),
-  LOOKUP_ADDR2: Buffer.from([241, 130]),
+  /** The relay servers a cloud lookup server names: `[count:1][pad:3]` then `count` address records. */
+  LIST_REQ_ACK: Buffer.from([241, 105]),
+  RLY_HELLO_ACK: Buffer.from([241, 113]),
+  /** A relay's answer to RLY_PORT: `[mark:4 BE][port:2 BE][pad:2]`, the port being the one it relays on. */
+  RLY_PORT_ACK: Buffer.from([241, 115]),
+  RLY_REQ_ACK: Buffer.from([241, 129]),
+  /** A relay endpoint to register with: one address record, then `[handle:4 BE]`. */
+  RLY_TO: Buffer.from([241, 130]),
   CAM_ID: Buffer.from([241, 66]),
+  /** A lookup server's answer to a P2P request: `[result:1]` first, 0 when the request is accepted. */
+  P2P_REQ_ACK: Buffer.from([241, 33]),
   /**
    * The device's own address record, sent in answer to CHECK_CAM ahead of CAM_ID: its 20-byte device id, one
-   * record in `encodeSelfAddress`'s shape naming the address it answers from, then 8 zero bytes (44-byte payload).
+   * record in `encodeAddress`'s shape naming the address it answers from, then 8 zero bytes (44-byte payload).
    */
   CAM_ADDR: Buffer.from([241, 67]),
-  TURN_SERVER_CAM_ID: Buffer.from([241, 132]),
+  /** A relay reporting the path to the device ready: the device's 20-byte id, sent from the relay endpoint. */
+  RLY_RDY: Buffer.from([241, 132]),
   PING: Buffer.from([241, 224]),
   PONG: Buffer.from([241, 225]),
   DATA: Buffer.from([241, 208]),
@@ -15398,7 +15418,7 @@ function buildLocalLookupPayload() {
 function buildLookupWithKeyPayload2(p2pDid, dskKey) {
   return Buffer.concat([p2pDidToBuffer(p2pDid), Buffer.from(dskKey), Buffer.from([0, 0, 0, 0])]);
 }
-function encodeSelfAddress(host, port) {
+function encodeAddress(host, port) {
   const out = Buffer.alloc(16);
   out.writeUInt16BE(2, 0);
   out.writeUInt16LE(port, 2);
@@ -15412,12 +15432,22 @@ function encodeSelfAddress(host, port) {
 function buildLookupWithKeyPayload(p2pDid, selfHost, selfPort, dskKey) {
   return Buffer.concat([
     p2pDidToBuffer(p2pDid),
-    encodeSelfAddress(selfHost, selfPort),
+    encodeAddress(selfHost, selfPort),
     Buffer.from([2, 5, 1, 5]),
     Buffer.from(dskKey),
     Buffer.from([0, 0, 0, 0])
   ]);
 }
+function buildRelayRequestPayload(p2pDid, relay, mark) {
+  const tail = Buffer.alloc(4);
+  tail.writeUInt32BE(mark >>> 0, 0);
+  return Buffer.concat([p2pDidToBuffer(p2pDid), encodeAddress(relay.host, relay.port), tail]);
+}
+function buildRelayPacketPayload(handle, p2pDid) {
+  const head = Buffer.alloc(4);
+  head.writeUInt32BE(handle >>> 0, 0);
+  return Buffer.concat([head, p2pDidToBuffer(p2pDid), Buffer.alloc(4)]);
+}
 function buildCheckCamPayload(p2pDid) {
   return Buffer.concat([p2pDidToBuffer(p2pDid), Buffer.from([0, 0, 0])]);
 }
@@ -15517,10 +15547,30 @@ function parseDataFrameHeader(frame) {
     type: frame.readUInt8(14)
   };
 }
+function readAddress(buf, offset) {
+  return {
+    host: `${buf[offset + 7]}.${buf[offset + 6]}.${buf[offset + 5]}.${buf[offset + 4]}`,
+    port: buf.readUInt16LE(offset + 2)
+  };
+}
 function parseLookupAddr(msg) {
-  const port = msg.subarray(6, 8).readUInt16LE();
-  const host = `${msg[11]}.${msg[10]}.${msg[9]}.${msg[8]}`;
-  return { host, port };
+  return readAddress(msg, 4);
+}
+function parseRelayList(msg) {
+  const out = [];
+  const count2 = msg.length > 4 ? msg[4] : 0;
+  for (let i = 0; i < count2 && 8 + 16 * (i + 1) <= msg.length; i++) {
+    const addr = readAddress(msg, 8 + 16 * i);
+    if (addr.host !== "0.0.0.0")
+      out.push(addr);
+  }
+  return out;
+}
+function parseRelayPortAck(msg) {
+  return msg.length >= 10 ? { mark: msg.readUInt32BE(4), port: msg.readUInt16BE(8) } : void 0;
+}
+function parseRelayTo(msg) {
+  return msg.length >= 24 ? { address: readAddress(msg, 4), handle: msg.readUInt32BE(20) } : void 0;
 }
 function readNullTerminatedString(data, encoding = "utf8") {
   const end = data.indexOf(0);
@@ -16140,6 +16190,8 @@ import { setTimeout as sleep2 } from "node:timers/promises";
 // dist/transport/p2p/p2p-session.js
 import { EventEmitter as EventEmitter2 } from "node:events";
 import dgram from "node:dgram";
+import { resolve4 } from "node:dns/promises";
+import { isIP as isIP2 } from "node:net";
 import { constants as constants2, createCipheriv as createCipheriv4, createDecipheriv as createDecipheriv4, generateKeyPairSync, privateDecrypt as privateDecrypt2, randomBytes as randomBytes4 } from "node:crypto";
 
 // dist/transport/p2p/live-trace.js
@@ -16153,8 +16205,10 @@ var LOCAL_LOOKUP_PORT = 32108;
 var HEARTBEAT_MS = 5e3;
 var PATH_SILENCE_MS = HEARTBEAT_MS * 3;
 var LOOKUP_RETRY_MS = 1e3;
+var RELAY_AFTER_ACKED_ROUNDS = 24;
+var RELAY_PACKET_COPIES = 4;
 var RECEIVE_BUFFER_BYTES = 4 * 1024 * 1024;
-var CONNECT_TIMEOUT_MS = 15e3;
+var CONNECT_TIMEOUT_MS = 45e3;
 var STATION_CHANNEL3 = 255;
 var CMD_GATEWAYINFO = 1100;
 var CMD_START_REALTIME_MEDIA = 1003;
@@ -16177,6 +16231,19 @@ var LIVE_START_RETRANSMIT_MS = 150;
 var LIVE_START_ACK_DEADLINE_MS = 3e3;
 var SEQUENCE_LOOKBACK = 32768;
 var STALE_RETRANSMIT_DEPTH = 1024;
+async function resolveLookupServers(addresses) {
+  const resolved = await Promise.all(addresses.map(async (addr) => {
+    if (isIP2(addr.host))
+      return addr;
+    try {
+      const [host] = await resolve4(addr.host);
+      return host ? { host, port: addr.port } : void 0;
+    } catch {
+      return void 0;
+    }
+  }));
+  return resolved.filter((addr) => addr !== void 0);
+}
 var PUNCH_PROBE_SOCKETS = 7;
 var REORDER_WAIT_MS = 250;
 var VIDEO_REORDER_WAIT_MS = 700;
@@ -16297,6 +16364,17 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   probeSockets = [];
   /** Cloud lookup inputs resolved once for a connection. */
   cloudLookup;
+  /**
+   * Lookup rounds since the lookup server acknowledged this connect's P2P request, or `undefined` while it
+   * has not; see {@link RELAY_AFTER_ACKED_ROUNDS}.
+   */
+  ackedRounds;
+  /**
+   * The relay handshake of a connect that has fallen back to one, by the step it waits on: the relay list
+   * (`list`, answering ListReq_DSK), a relay's hello acknowledgement (`hello`), that relay's port (`port`),
+   * then the relay-ready the device's registration produces (`request`, re-sending RLY_REQ meanwhile).
+   */
+  relay;
   /** Local outbound IPv4 reported inside LOOKUP_WITH_KEY requests. */
   selfHost;
   /**
@@ -16646,6 +16724,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.connecting = true;
     this.closed = false;
     this.connectionGeneration += 1;
+    this.ackedRounds = void 0;
     this.resetInboundSequencing();
     if (!this.level2KeyServes("set-payload")) {
       this.level2Pending = this.cfg.resolveCipherKey !== void 0;
@@ -16674,6 +16753,13 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     });
     const { dskKey, cloudAddresses } = this.cfg;
     this.cloudLookup = dskKey && cloudAddresses?.length ? { key: dskKey, addresses: cloudAddresses } : void 0;
+    if (this.cloudLookup && cloudAddresses) {
+      const generation = this.connectionGeneration;
+      void resolveLookupServers(cloudAddresses).then((addresses) => {
+        if (this.cloudLookup && !this.closed && generation === this.connectionGeneration)
+          this.cloudLookup.addresses = addresses;
+      });
+    }
     if (this.cloudLookup)
       await this.startPunchProbes();
     if (this.closed)
@@ -16688,7 +16774,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.lookupTimer = setInterval(() => this.sendLookups(), LOOKUP_RETRY_MS);
     this.connectTimer = setTimeout(() => {
       if (!this.connected) {
-        this.emit("error", new Error(`P2P connect timeout for ${this.cfg.stationSn}`));
+        this.emit("error", new Error(`P2P connect timeout for ${this.cfg.stationSn} (${this.relayProgress()})`));
         void this.close();
       }
     }, CONNECT_TIMEOUT_MS);
@@ -16766,6 +16852,84 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
         this.sendCloudLookup(socket, lookup2);
       this.logger.debug(`[p2p] ${this.cfg.stationSn} sendLookups: cloud -> ${lookup2.addresses.map((a) => `${a.host}:${a.port}`).join(", ")} self=${this.selfHost ?? "unknown"}`);
     }
+    this.countAckedRound();
+    this.sendRelay();
+  }
+  /** Step {@link ackedRounds} for one lookup round, and start the relay handshake once it passes its threshold. */
+  countAckedRound() {
+    if (this.ackedRounds === void 0 || this.relay || !this.cloudLookup)
+      return;
+    this.ackedRounds += 1;
+    if (this.ackedRounds > RELAY_AFTER_ACKED_ROUNDS)
+      this.relay = { step: "list", relays: [] };
+  }
+  /**
+   * How far this connect got towards a relay: the handshake step it was waiting on (`list` meaning no lookup
+   * server named a relay), `not started` where it had not fallen back yet, or `no cloud lookup` where it could
+   * not.
+   */
+  relayProgress() {
+    return `relay: ${this.relay?.step ?? (this.cloudLookup ? "not started" : "no cloud lookup")}`;
+  }
+  /**
+   * Send the relay handshake's message for the step it waits on, from the session's own socket.
+   *
+   * The order is the vendor client's: ListReq_DSK to the cloud lookup servers, RLY_HELLO to every relay they
+   * list, RLY_PORT to the first of those relays that acknowledges, then RLY_REQ to the lookup servers naming
+   * that relay's port and mark. The lookup server has the device register with the relay, and the relay
+   * answers RLY_RDY.
+   */
+  sendRelay() {
+    const relay = this.relay;
+    const lookup2 = this.cloudLookup;
+    if (!relay || !lookup2 || this.connected)
+      return;
+    if (relay.step === "list") {
+      const payload = buildLookupWithKeyPayload2(this.cfg.p2pDid, lookup2.key);
+      for (const addr of lookup2.addresses)
+        this.send(addr, RequestMessageType.LOOKUP_WITH_KEY2, payload);
+    } else if (relay.step === "hello") {
+      for (const addr of relay.relays)
+        this.send(addr, RequestMessageType.RLY_HELLO);
+    } else if (relay.step === "port" && relay.via) {
+      this.send(relay.via, RequestMessageType.RLY_PORT);
+    } else if (relay.step === "request" && relay.via && relay.mark !== void 0) {
+      const payload = buildRelayRequestPayload(this.cfg.p2pDid, relay.via, relay.mark);
+      for (const addr of lookup2.addresses)
+        this.send(addr, RequestMessageType.RLY_REQ, payload);
+    }
+  }
+  /** Advance the relay handshake on one of its answers, arriving on the session's own socket. */
+  onRelayMessage(msg, rinfo) {
+    const relay = this.relay;
+    if (!relay || this.connected)
+      return;
+    if (hasHeader(msg, ResponseMessageType.LIST_REQ_ACK)) {
+      if (relay.step !== "list" && relay.step !== "hello")
+        return;
+      for (const listed of parseRelayList(msg))
+        if (!relay.relays.some((known) => known.host === listed.host && known.port === listed.port))
+          relay.relays.push(listed);
+      if (relay.relays.length)
+        relay.step = "hello";
+    } else if (hasHeader(msg, ResponseMessageType.RLY_HELLO_ACK)) {
+      const listed = relay.relays.some((known) => known.host === rinfo.address && known.port === rinfo.port);
+      if (relay.step !== "hello" || !listed)
+        return;
+      relay.via = { host: rinfo.address, port: rinfo.port };
+      relay.step = "port";
+    } else if (hasHeader(msg, ResponseMessageType.RLY_PORT_ACK)) {
+      const ack = parseRelayPortAck(msg);
+      if (relay.step !== "port" || !relay.via || !ack)
+        return;
+      relay.via = { host: relay.via.host, port: ack.port };
+      relay.mark = ack.mark;
+      relay.step = "request";
+    } else {
+      return;
+    }
+    this.logger.debug(`[p2p] ${this.cfg.stationSn} relay -> ${relay.step}`);
+    this.sendRelay();
   }
   /** Register a bound socket's own port with each configured cloud lookup address. */
   sendCloudLookup(socket, lookup2) {
@@ -16778,15 +16942,17 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * Route one inbound UDP datagram by its message type, tracing every non-DATA one and any type this session
    * does not model.
    *
-   * An unmodelled type is not by itself evidence about a session that is failing. `0xf169` — a relay-pool
-   * listing answering a cloud lookup, which a connected session has no use for — reaches the UNHANDLED branch
-   * on the sessions of cameras that stream and cameras that do not alike. `0xf121` has been observed
-   * straddling a level-2 wait on a camera whose failure to deliver video had a separate cause, and did not
-   * recur across later probes of it. Correlate an unmodelled type against a WORKING session before reading it
-   * as a cause.
+   * An unmodelled type is not by itself evidence about a session that is failing. Correlate one against a
+   * WORKING session before reading it as a cause.
+   *
+   * P2P_REQ_ACK is the lookup server acknowledging this connect's P2P request; the first one carrying result 0
+   * starts the round count {@link RELAY_AFTER_ACKED_ROUNDS} measures.
    *
    * CAM_ADDR is recognised and dropped: it names the address the device is already answering from, and the
-   * CAM_ID that follows it is what completes the connect.
+   * CAM_ID that follows it is what completes the connect. RLY_TO is a relay endpoint, never the device: it is
+   * answered with {@link RELAY_PACKET_COPIES} RLY_PKTs carrying its handle, and the RLY_RDY naming this
+   * session's device completes the connect with the relay as the peer. The other relay answers advance the
+   * handshake {@link sendRelay} drives, and are dropped outside it.
    */
   onMessage(msg, rinfo, socket = this.socket) {
     if (!socket)
@@ -16802,14 +16968,33 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     if (hasHeader(msg, ResponseMessageType.LOCAL_LOOKUP_RESP)) {
       if (!this.connected)
         this.beginCheckCam({ host: rinfo.address, port: rinfo.port }, socket);
-    } else if (hasHeader(msg, ResponseMessageType.LOOKUP_ADDR) || hasHeader(msg, ResponseMessageType.LOOKUP_ADDR2)) {
+    } else if (hasHeader(msg, ResponseMessageType.LOOKUP_ADDR)) {
       if (!this.connected) {
         const addr = parseLookupAddr(msg);
         this.logger.debug(`[p2p] ${this.cfg.stationSn} LOOKUP_ADDR -> ${addr.host}:${addr.port}`);
         if (addr.host !== "0.0.0.0")
           this.beginCheckCam(addr, socket);
       }
-    } else if (hasHeader(msg, ResponseMessageType.CAM_ID) || hasHeader(msg, ResponseMessageType.TURN_SERVER_CAM_ID)) {
+    } else if (hasHeader(msg, ResponseMessageType.RLY_TO)) {
+      const to = parseRelayTo(msg);
+      if (!this.connected && to && to.address.host !== "0.0.0.0") {
+        this.logger.debug(`[p2p] ${this.cfg.stationSn} RLY_TO -> ${to.address.host}:${to.address.port}`);
+        const payload = buildRelayPacketPayload(to.handle, this.cfg.p2pDid);
+        for (let i = 0; i < RELAY_PACKET_COPIES; i++)
+          this.send(to.address, RequestMessageType.RLY_PKT, payload, socket);
+      }
+    } else if (hasHeader(msg, ResponseMessageType.RLY_RDY)) {
+      if (msg.subarray(4, 24).equals(p2pDidToBuffer(this.cfg.p2pDid))) {
+        this.logger.debug(`[p2p] ${this.cfg.stationSn} RLY_RDY from relay ${rinfo.address}:${rinfo.port}`);
+        this.onConnected({ host: rinfo.address, port: rinfo.port }, socket);
+      }
+    } else if (hasHeader(msg, ResponseMessageType.P2P_REQ_ACK)) {
+      if (!this.connected && this.ackedRounds === void 0 && msg.length > 4 && msg[4] === 0)
+        this.ackedRounds = 0;
+    } else if (hasHeader(msg, ResponseMessageType.LIST_REQ_ACK) || hasHeader(msg, ResponseMessageType.RLY_HELLO_ACK) || hasHeader(msg, ResponseMessageType.RLY_PORT_ACK) || hasHeader(msg, ResponseMessageType.RLY_REQ_ACK)) {
+      if (socket === this.socket)
+        this.onRelayMessage(msg, rinfo);
+    } else if (hasHeader(msg, ResponseMessageType.CAM_ID)) {
       this.onConnected({ host: rinfo.address, port: rinfo.port }, socket);
     } else if (hasHeader(msg, ResponseMessageType.END)) {
       if (fromConnectedPeer)
@@ -16897,6 +17082,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       clearInterval(this.lookupTimer);
     if (this.connectTimer)
       clearTimeout(this.connectTimer);
+    this.relay = void 0;
     this.logger.debug(`[p2p] ${this.cfg.stationSn} connected ${addr.host}:${addr.port}`);
     this.sendCommand(CMD_GATEWAYINFO);
     this.send(addr, RequestMessageType.PING, this.lastPongData);
@@ -18076,6 +18262,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       clearInterval(this.heartbeatTimer);
     if (this.connectTimer)
       clearTimeout(this.connectTimer);
+    this.relay = void 0;
     if (this.audioRetransmitTimer)
       clearInterval(this.audioRetransmitTimer);
     this.audioRetransmitTimer = void 0;
@@ -22086,6 +22273,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
    */
   async openMediaSession(parentSn, channel, signal) {
     const session = await this.openSession(_P2PCommandRouter.mediaSessionKey(parentSn, channel), parentSn);
+    await this.awaitConnected(session, parentSn, signal);
     let ready = await abortable(session.awaitLevel2Key(LEVEL2_GRACE_MS, "call"), signal);
     if (!ready && session.repromptLevel2Key()) {
       ready = await abortable(session.awaitLevel2Key(LEVEL2_GRACE_MS, "call"), signal);
@@ -22094,6 +22282,30 @@ var P2PCommandRouter = class _P2PCommandRouter {
       throw new StationKeyUnavailableError(parentSn);
     return session;
   }
+  /**
+   * Wait for `session` to connect, for up to the session's own connect deadline, and throw
+   * {@link StationUnreachableError} when it does not.
+   *
+   * `connect()` resolves once the lookups are under way, not once a path answers, so a session handed back by
+   * {@link openSession} may still be connecting: a relay connect lands about 25 s in. A level-2 grace counted
+   * before this would be spent on the connect rather than on the key.
+   */
+  async awaitConnected(session, parentSn, signal) {
+    const t0 = Date.now();
+    let waitedMs = 0;
+    if (!session.isConnected) {
+      this.traceOnStation(session, { phase: "session-connect-wait", waitMs: P2P_STATION_WAITS.connect });
+      while (!session.isConnected && Date.now() - t0 < P2P_STATION_WAITS.connect) {
+        signal?.throwIfAborted();
+        await sleep2(200);
+      }
+      waitedMs = Date.now() - t0;
+      this.traceOnStation(session, session.isConnected ? { phase: "session-connected", waitedMs } : { phase: "session-unreachable", waitedMs });
+    }
+    signal?.throwIfAborted();
+    if (!session.isConnected)
+      throw new StationUnreachableError(parentSn, waitedMs);
+  }
   /** Open (or reuse) the session filed under `key`, dialling `parentSn`'s endpoint. */
   async openSession(key, parentSn) {
     return this.manager.acquire(key, async (register) => {
@@ -23143,20 +23355,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
       stationAdmin: typeof stationAdminId !== "string" ? "unstated" : stationAdminId === this.deps.mega.auth?.userId ? "self" : "other",
       ...stationModel ? { stationModel } : {}
     });
-    const t0 = Date.now();
-    let waitedMs = 0;
-    if (!session.isConnected) {
-      this.traceOnStation(session, { phase: "session-connect-wait", waitMs: P2P_STATION_WAITS.connect });
-      while (!session.isConnected && Date.now() - t0 < P2P_STATION_WAITS.connect) {
-        opts.signal?.throwIfAborted();
-        await sleep2(200);
-      }
-      waitedMs = Date.now() - t0;
-      this.traceOnStation(session, session.isConnected ? { phase: "session-connected", waitedMs } : { phase: "session-unreachable", waitedMs });
-    }
-    opts.signal?.throwIfAborted();
-    if (!session.isConnected)
-      throw new StationUnreachableError(parentSn, waitedMs);
+    await this.awaitConnected(session, parentSn, opts.signal);
     if (opts.waitLevel2) {
       if (opts.waitLevel2 === "settle") {
         await abortable(session.awaitLevel2Key(LEVEL2_SETTLE_MS, "session"), opts.signal);
@@ -25570,10 +25769,10 @@ var RtcCommandRouter = class {
 import { randomBytes as randomBytes5 } from "node:crypto";
 
 // dist/transport/mqtt/broker-discovery.js
-import { resolve4 } from "node:dns/promises";
+import { resolve4 as resolve42 } from "node:dns/promises";
 async function resolveBrokerIps(hostname) {
   try {
-    return await resolve4(hostname);
+    return await resolve42(hostname);
   } catch {
     return [];
   }