@mega-yfue/eufy-sdk 0.6.0-beta.37 → 0.6.0-beta.39

package/dist/index.js

@@ -4800,11 +4800,20 @@ function cellGated(members) {
   });
   return Object.fromEntries(gated);
 }
+var notSensor = (ctx) => ctx.codec !== "sensor";
+function notOnSensor(members) {
+  const gated = Object.entries(members).map(([name, m]) => {
+    const own = m.available;
+    const available = own ? (ctx) => notSensor(ctx) && own(ctx) : notSensor;
+    return [name, { ...m, available }];
+  });
+  return Object.fromEntries(gated);
+}
 function isChargingState(v) {
   const n = Number(v);
   return n !== 0 && n !== 2;
 }
-var BATTERY_MEMBERS = cellGated({
+var CAMERA_BATTERY_MEMBERS = cellGated({
   /**
    * The headline percentage, and this capability's detection evidence: reporting 1101 is what proves a
    * device is battery-powered, which is also the fact `MediaProvider` reads to decide a stream needs a
@@ -5031,6 +5040,7 @@ var BATTERY_MEMBERS = cellGated({
     description: "Raw GET_CAMERA_INFO value (1103), meaning unevidenced \u2014 read live as the constant 5 on a T8170 at 92% and a T8171 at 27%, so it is NOT a low-battery flag."
   }
 });
+var BATTERY_MEMBERS = notOnSensor(CAMERA_BATTERY_MEMBERS);
 var BATTERY = {
   capability: "battery",
   description: "Battery level, charging, health, temperature, and solar input.",
@@ -15325,6 +15335,7 @@ __export(codec_exports, {
   encryptP2PData: () => encryptP2PData,
   frameMessage: () => frameMessage,
   gatewayInfoCipherId: () => gatewayInfoCipherId,
+  gatewayInfoRefused: () => gatewayInfoRefused,
   hasHeader: () => hasHeader,
   p2pCommandEncryptionKey: () => p2pCommandEncryptionKey,
   p2pDidToBuffer: () => p2pDidToBuffer,
@@ -15443,6 +15454,10 @@ function decryptP2PData(data, key) {
 function gatewayInfoCipherId(gwPayload) {
   return gwPayload.length >= 2 ? gwPayload.readUInt16LE(0) : 0;
 }
+var GATEWAY_LEVEL2_REFUSED = -103;
+function gatewayInfoRefused(gwPayload) {
+  return gwPayload.length >= 4 && gwPayload.readInt32LE(0) === GATEWAY_LEVEL2_REFUSED;
+}
 function eufyKdf(shared, outLen) {
   const hmac = (k, d) => createHmac2("sha256", k).update(d).digest();
   const label = Buffer.from("ECIES");
@@ -16588,6 +16603,8 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
   liveStartedChannels = /* @__PURE__ */ new Map();
   /** The `cipher_id` this connection's `CMD_GATEWAYINFO` reply named, once its negotiation has read it. */
   gatewayCipherId;
+  /** Whether this connection's latest `CMD_GATEWAYINFO` reply was a refusal — see {@link gatewayInfoRefused}. */
+  gatewayRefused = false;
   /** The `n` of the last `[0x01, n]` header this connection sent in the clear — see {@link nextClearCommandBytes}. */
   clearCommandCount = 0;
   unackedLiveStarts = /* @__PURE__ */ new Map();
@@ -16785,9 +16802,17 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * Every outcome settles the wait in {@link awaitLevel2Key}, so a later command is told at once rather than
    * left to time out against a key that is not coming. Settling also re-opens the negotiation, so a later
    * GATEWAYINFO reply in the same connection generation runs it again; a lookup that completes after its
-   * generation ended settles nothing.
+   * generation ended settles nothing. A {@link gatewayInfoRefused} reply names no cipher, so it settles at once
+   * with no cloud lookup, and a later reply naming a cipher withdraws the refusal.
    */
   negotiateLevel2Key(gwPayload) {
+    this.gatewayRefused = gatewayInfoRefused(gwPayload);
+    if (this.gatewayRefused) {
+      this.logger.debug(`[p2p] ${this.cfg.stationSn} gateway info refused level-2`);
+      this.trace({ phase: "level2-unavailable", reason: "gateway-refused" });
+      this.settleLevel2();
+      return;
+    }
     this.level2Negotiating = true;
     const generation = this.connectionGeneration;
     const cipherId = gatewayInfoCipherId(gwPayload);
@@ -16910,6 +16935,7 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       this.level2Negotiating = false;
       this.level2Reprompted = false;
       this.gatewayCipherId = void 0;
+      this.gatewayRefused = false;
       this.clearCommandCount = 0;
     }
     const socket = dgram.createSocket("udp4");
@@ -17534,6 +17560,13 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
     this.seqNumber = this.seqNumber + 1 & 65535;
     this.send(this.connectAddress, RequestMessageType.DATA, data);
   }
+  /**
+   * Whether this connection's station answered `CMD_GATEWAYINFO` with a refusal ({@link gatewayInfoRefused}) and
+   * no key that frames a set-payload is held.
+   */
+  get refusedLevel2() {
+    return this.gatewayRefused && !this.level2KeyServes("set-payload");
+  }
   /**
    * Send a **level-2 (AES-256-GCM, signCode 8) control payload** to a HomeBase-attached device. The
    * target camera is selected by `channel` (= device_channel) + the `mChannel` envelope — the same
@@ -17544,10 +17577,15 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
    * On a session holding only the AES-128-ECB level-2 key of an RSA cipher, the frame is the level-1
    * layout ({@link sendRawLevel1Bytes}) sealed under that key at encryption type 2: the encryption-type
    * byte names the key the body is sealed with (1 = level-1 key, 2 = the negotiated key).
+   *
+   * With `clearOnRefusal` on a session that {@link refusedLevel2}, the frame goes in the clear in the vendor
+   * app's form for such a device: header bytes `[01 00]`, signCode 0, and a body of `{cmd, payload}` alone.
+   * Without it, a refused session answers `false` and sends nothing.
    */
-  sendControlLevel2(cmd, channel, accountId, payload, mValue3 = cmd) {
-    if (!this.connectAddress || !this.level2KeyServes("set-payload"))
+  sendControlLevel2(cmd, channel, accountId, payload, mValue3 = cmd, clearOnRefusal = false) {
+    if (!this.connectAddress || !(this.level2KeyServes("set-payload") || clearOnRefusal && this.refusedLevel2)) {
       return false;
+    }
     const value = Buffer.from(JSON.stringify({ account_id: accountId, cmd, mChannel: channel, mValue3, payload }), "utf-8");
     let sealed;
     if (this.level2Key) {
@@ -17555,8 +17593,10 @@ var P2PSession = class _P2PSession extends EventEmitter2 {
       if (!body)
         return false;
       sealed = buildRawCommandPayload(body, channel, 8, [8, 0], 0);
-    } else {
+    } else if (this.level2EcbKey) {
       sealed = buildRawCommandPayload(encryptP2PData(paddingP2PData(value), this.level2EcbKey), channel, 2);
+    } else {
+      sealed = buildRawCommandPayload(Buffer.from(JSON.stringify({ cmd, payload }), "utf-8"), channel);
     }
     const data = Buffer.concat([buildCommandHeader(this.seqNumber, CMD_SET_PAYLOAD), sealed]);
     this.seqNumber = this.seqNumber + 1 & 65535;
@@ -18909,169 +18949,6 @@ import { EventEmitter as EventEmitter3 } from "node:events";
 
 // dist/transport/p2p/video.js
 import { createDecipheriv as createDecipheriv6 } from "node:crypto";
-var VIDEO_GCM_AAD = Buffer.from("eufy security");
-var HEADER_LEN = 22;
-var ENVELOPE_OFFSET = 22;
-var ENVELOPE_LEN = 129;
-var GCM_TAG_OFFSET = 151;
-var GCM_TAG_LEN = 16;
-var GCM_NONCE_OFFSET = 167;
-var GCM_NONCE_LEN = 12;
-var BODY_OFFSET = 179;
-function parseVideoFrameHeader(payload) {
-  if (payload.length < HEADER_LEN)
-    return void 0;
-  const flags = payload.readUInt8(4);
-  return {
-    payloadLength: payload.readUInt32LE(0),
-    keyframe: (flags & 1) === 1,
-    flags,
-    sequence: payload.readUInt16LE(6),
-    width: payload.readInt16LE(10),
-    height: payload.readInt16LE(12),
-    timestamp: payload.readUInt32LE(14)
-  };
-}
-var VideoFrameDecoder = class {
-  eccPrivateKeyHex;
-  mediaKey;
-  /** @param eccPrivateKey the camera's 32-byte ECC private key (P-256 scalar). */
-  constructor(eccPrivateKey) {
-    if (eccPrivateKey.length !== 32)
-      throw new Error("eccPrivateKey must be 32 bytes");
-    this.eccPrivateKeyHex = eccPrivateKey.toString("hex");
-  }
-  /** The media key recovered from the most recent keyframe, if any. */
-  get currentMediaKey() {
-    return this.mediaKey ? Buffer.from(this.mediaKey) : void 0;
-  }
-  /**
-   * Recover the per-stream media key from a keyframe's 129-byte ECIES envelope: ECIES unwrap
-   * (ECDH → eufyKDF → AES-128-CBC, with the trailing HMAC verified) → 32-byte AES-256-GCM key.
-   */
-  unwrapMediaKey(envelope) {
-    const key = eciesUnwrap(envelope, this.eccPrivateKeyHex, { verifyHmac: true, pkcs7: true });
-    return key && key.length === 32 ? key : void 0;
-  }
-  /**
-   * Decode one video frame. Returns the keyframe flag and decrypted H.264 bytes, or `undefined`
-   * if the frame is malformed, the envelope/key is wrong, or GCM authentication fails.
-   */
-  decodeFrame(payload) {
-    const header = parseVideoFrameHeader(payload);
-    if (!header)
-      return void 0;
-    if (header.keyframe) {
-      if (payload.length < ENVELOPE_OFFSET + ENVELOPE_LEN)
-        return void 0;
-      const envelope = payload.subarray(ENVELOPE_OFFSET, ENVELOPE_OFFSET + ENVELOPE_LEN);
-      const key = this.unwrapMediaKey(envelope);
-      if (!key)
-        return void 0;
-      this.mediaKey = key;
-    }
-    const mediaKey = this.mediaKey;
-    if (!mediaKey)
-      return void 0;
-    if (payload.length < BODY_OFFSET)
-      return void 0;
-    const tag2 = payload.subarray(GCM_TAG_OFFSET, GCM_TAG_OFFSET + GCM_TAG_LEN);
-    const nonce = payload.subarray(GCM_NONCE_OFFSET, GCM_NONCE_OFFSET + GCM_NONCE_LEN);
-    const body = payload.subarray(BODY_OFFSET);
-    try {
-      const dec2 = createDecipheriv6("aes-256-gcm", mediaKey, nonce);
-      dec2.setAAD(VIDEO_GCM_AAD);
-      dec2.setAuthTag(tag2);
-      const head = dec2.update(body);
-      const tail = dec2.final();
-      const h264 = tail.length ? Buffer.concat([head, tail]) : head;
-      return { keyframe: header.keyframe, h264, width: header.width, height: header.height };
-    } catch {
-      return void 0;
-    }
-  }
-};
-var STATION_CHUNK_BYTES = 64e3;
-var AccessUnitAssembler = class {
-  onDropped;
-  chunkBytes;
-  open;
-  droppedUnits = 0;
-  /**
-   * @param onDropped called for each incomplete unit discarded, with what had arrived, how many frames it
-   * arrived in, and how many this assembler has dropped in total — a running count, so no caller keeps
-   * its own.
-   * @param chunkBytes the payload size the station fills a frame to before continuing a unit in the next. A
-   * unit is held while its latest frame declares exactly this. {@link STATION_CHUNK_BYTES} when omitted.
-   */
-  constructor(onDropped, chunkBytes = STATION_CHUNK_BYTES) {
-    this.onDropped = onDropped;
-    this.chunkBytes = chunkBytes;
-  }
-  /**
-   * Feed one raw `CMD_VIDEO_FRAME` payload; returns the access units it completed — none while a unit is
-   * still being filled, one in the ordinary case.
-   *
-   * `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). 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, decode) {
-    const header = parseVideoFrameHeader(payload);
-    const body = header && decode(payload);
-    if (!header || !body?.length) {
-      this.discard();
-      return [];
-    }
-    const full = header.payloadLength === this.chunkBytes;
-    const open2 = this.open;
-    if (open2 && sameUnit(open2.header, header) && !beginsAccessUnit(body)) {
-      open2.chunks.push(body);
-      open2.carried += body.length;
-      if (full)
-        return [];
-      this.open = void 0;
-      return [unitOf(open2.header, Buffer.concat(open2.chunks))];
-    }
-    this.discard();
-    if (!beginsAccessUnit(body))
-      return [];
-    if (full) {
-      this.open = { header, chunks: [body], carried: body.length };
-      return [];
-    }
-    return [unitOf(header, body)];
-  }
-  /** Forget an incomplete unit, counting and reporting it. */
-  discard() {
-    const open2 = this.open;
-    if (!open2)
-      return;
-    this.open = void 0;
-    this.droppedUnits++;
-    this.onDropped?.({ carried: open2.carried, chunks: open2.chunks.length, count: this.droppedUnits });
-  }
-};
-var SPLIT_UNIT_STAMP_SPREAD_MS = 100;
-function sameUnit(open2, next) {
-  return next.sequence === open2.sequence && next.timestamp - open2.timestamp >>> 0 <= SPLIT_UNIT_STAMP_SPREAD_MS;
-}
-function beginsAccessUnit(body) {
-  if (body.length < 4 || body[0] !== 0 || body[1] !== 0)
-    return false;
-  return body[2] === 1 || body[2] === 0 && body[3] === 1;
-}
-function unitOf(header, data) {
-  return {
-    sourceTimestamp: header.timestamp,
-    keyframe: header.keyframe,
-    width: header.width,
-    height: header.height,
-    data
-  };
-}
 
 // dist/transport/p2p/annexb.js
 var ANNEXB_START = Buffer.from([0, 0, 0, 1]);
@@ -19389,6 +19266,172 @@ function h265Geometry(sps) {
   };
 }
 
+// dist/transport/p2p/video.js
+var VIDEO_GCM_AAD = Buffer.from("eufy security");
+var HEADER_LEN = 22;
+var ENVELOPE_OFFSET = 22;
+var ENVELOPE_LEN = 129;
+var GCM_TAG_OFFSET = 151;
+var GCM_TAG_LEN = 16;
+var GCM_NONCE_OFFSET = 167;
+var GCM_NONCE_LEN = 12;
+var BODY_OFFSET = 179;
+function parseVideoFrameHeader(payload) {
+  if (payload.length < HEADER_LEN)
+    return void 0;
+  const flags = payload.readUInt8(4);
+  return {
+    payloadLength: payload.readUInt32LE(0),
+    keyframe: (flags & 1) === 1,
+    flags,
+    sequence: payload.readUInt16LE(6),
+    width: payload.readInt16LE(10),
+    height: payload.readInt16LE(12),
+    timestamp: payload.readUInt32LE(14)
+  };
+}
+var VideoFrameDecoder = class {
+  eccPrivateKeyHex;
+  mediaKey;
+  /** @param eccPrivateKey the camera's 32-byte ECC private key (P-256 scalar). */
+  constructor(eccPrivateKey) {
+    if (eccPrivateKey.length !== 32)
+      throw new Error("eccPrivateKey must be 32 bytes");
+    this.eccPrivateKeyHex = eccPrivateKey.toString("hex");
+  }
+  /** The media key recovered from the most recent keyframe, if any. */
+  get currentMediaKey() {
+    return this.mediaKey ? Buffer.from(this.mediaKey) : void 0;
+  }
+  /**
+   * Recover the per-stream media key from a keyframe's 129-byte ECIES envelope: ECIES unwrap
+   * (ECDH → eufyKDF → AES-128-CBC, with the trailing HMAC verified) → 32-byte AES-256-GCM key.
+   */
+  unwrapMediaKey(envelope) {
+    const key = eciesUnwrap(envelope, this.eccPrivateKeyHex, { verifyHmac: true, pkcs7: true });
+    return key && key.length === 32 ? key : void 0;
+  }
+  /**
+   * Decode one video frame. Returns the keyframe flag and decrypted H.264 bytes, or `undefined`
+   * if the frame is malformed, the envelope/key is wrong, or GCM authentication fails.
+   */
+  decodeFrame(payload) {
+    const header = parseVideoFrameHeader(payload);
+    if (!header)
+      return void 0;
+    if (header.keyframe) {
+      if (payload.length < ENVELOPE_OFFSET + ENVELOPE_LEN)
+        return void 0;
+      const envelope = payload.subarray(ENVELOPE_OFFSET, ENVELOPE_OFFSET + ENVELOPE_LEN);
+      const key = this.unwrapMediaKey(envelope);
+      if (!key)
+        return void 0;
+      this.mediaKey = key;
+    }
+    const mediaKey = this.mediaKey;
+    if (!mediaKey)
+      return void 0;
+    if (payload.length < BODY_OFFSET)
+      return void 0;
+    const tag2 = payload.subarray(GCM_TAG_OFFSET, GCM_TAG_OFFSET + GCM_TAG_LEN);
+    const nonce = payload.subarray(GCM_NONCE_OFFSET, GCM_NONCE_OFFSET + GCM_NONCE_LEN);
+    const body = payload.subarray(BODY_OFFSET);
+    try {
+      const dec2 = createDecipheriv6("aes-256-gcm", mediaKey, nonce);
+      dec2.setAAD(VIDEO_GCM_AAD);
+      dec2.setAuthTag(tag2);
+      const head = dec2.update(body);
+      const tail = dec2.final();
+      const h264 = tail.length ? Buffer.concat([head, tail]) : head;
+      return { keyframe: header.keyframe, h264, width: header.width, height: header.height };
+    } catch {
+      return void 0;
+    }
+  }
+};
+var STATION_CHUNK_BYTES = 64e3;
+var AccessUnitAssembler = class {
+  onDropped;
+  chunkBytes;
+  open;
+  droppedUnits = 0;
+  /**
+   * @param onDropped called for each incomplete unit discarded, with what had arrived, how many frames it
+   * arrived in, and how many this assembler has dropped in total — a running count, so no caller keeps
+   * its own.
+   * @param chunkBytes the payload size the station fills a frame to before continuing a unit in the next. A
+   * unit is held while its latest frame declares exactly this. {@link STATION_CHUNK_BYTES} when omitted.
+   */
+  constructor(onDropped, chunkBytes = STATION_CHUNK_BYTES) {
+    this.onDropped = onDropped;
+    this.chunkBytes = chunkBytes;
+  }
+  /**
+   * Feed one raw `CMD_VIDEO_FRAME` payload; returns the access units it completed — none while a unit is
+   * still being filled, one in the ordinary case.
+   *
+   * `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). 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, decode) {
+    const header = parseVideoFrameHeader(payload);
+    const body = header && decode(payload);
+    if (!header || !body?.length) {
+      this.discard();
+      return [];
+    }
+    const full = header.payloadLength === this.chunkBytes;
+    const open2 = this.open;
+    if (open2 && sameUnit(open2.header, header) && !beginsAccessUnit(body)) {
+      open2.chunks.push(body);
+      open2.carried += body.length;
+      if (full)
+        return [];
+      this.open = void 0;
+      return [unitOf(open2.header, Buffer.concat(open2.chunks))];
+    }
+    this.discard();
+    if (!beginsAccessUnit(body))
+      return [];
+    if (full) {
+      this.open = { header, chunks: [body], carried: body.length };
+      return [];
+    }
+    return [unitOf(header, body)];
+  }
+  /** Forget an incomplete unit, counting and reporting it. */
+  discard() {
+    const open2 = this.open;
+    if (!open2)
+      return;
+    this.open = void 0;
+    this.droppedUnits++;
+    this.onDropped?.({ carried: open2.carried, chunks: open2.chunks.length, count: this.droppedUnits });
+  }
+};
+var SPLIT_UNIT_STAMP_SPREAD_MS = 100;
+function sameUnit(open2, next) {
+  return next.sequence === open2.sequence && next.timestamp - open2.timestamp >>> 0 <= SPLIT_UNIT_STAMP_SPREAD_MS;
+}
+function beginsAccessUnit(body) {
+  if (body.length < 4 || body[0] !== 0 || body[1] !== 0)
+    return false;
+  return body[2] === 1 || body[2] === 0 && body[3] === 1;
+}
+function unitOf(header, data) {
+  const codec = header.keyframe ? void 0 : sniffAnnexbCodec(data);
+  return {
+    sourceTimestamp: header.timestamp,
+    keyframe: header.keyframe || codec !== void 0 && hasIdr(data, codec),
+    width: header.width,
+    height: header.height,
+    data
+  };
+}
+
 // dist/transport/p2p/audio-frame.js
 import { createDecipheriv as createDecipheriv7 } from "node:crypto";
 var CMD_AUDIO_FRAME2 = 1301;
@@ -22419,6 +22462,7 @@ var RTSP_URL_READ_TIMEOUT_MS = 12e3;
 var TALKBACK_CODEC_WAIT_MS = 3e3;
 var OWN_LIVE_SESSION_MODELS = /* @__PURE__ */ new Set(["T8030"]);
 var ELD_TALKBACK_MODELS = /* @__PURE__ */ new Set(["T8410C"]);
+var CLEAR_FF09_MODELS = /* @__PURE__ */ new Set(["T8506"]);
 function speakerCodec(consumer, talk, timeoutMs) {
   return new Promise((resolve2) => {
     let timer;
@@ -23764,6 +23808,9 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * sources on the replaced session are discarded before closing it (see {@link tearDownStation}).
    * Replaced at most once per resolution, so a station whose replacement is silent too is returned rather
    * than closed again.
+   *
+   * `clearFallback` hands over a session whose station {@link P2PSession.refusedLevel2} instead of throwing, for
+   * a standalone device of a model in {@link CLEAR_FF09_MODELS}.
    */
   async resolveSession(sn, opts = {}, rebuilt = false) {
     const dev = await this.deviceFor(sn);
@@ -23815,8 +23862,10 @@ var P2PCommandRouter = class _P2PCommandRouter {
       if (!ready && session.repromptLevel2Key()) {
         ready = await abortable(session.awaitLevel2Key(LEVEL2_GRACE_MS, "call", sender), opts.signal);
       }
-      if (!ready)
+      const sendsClear = opts.clearFallback === true && !homeBaseAttached && CLEAR_FF09_MODELS.has(this.recordFor(sn)?.model ?? "") && session.refusedLevel2;
+      if (!ready && !sendsClear)
         throw new StationKeyUnavailableError(parentSn);
+      return { session, parentSn, channel, accountId, homeBaseAttached, sendsClear };
     }
     return { session, parentSn, channel, accountId, homeBaseAttached };
   }
@@ -23926,7 +23975,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
       });
       return;
     }
-    await this.replayLevel2Send(sn, `set-payload cmd ${cmd}`, ({ session, accountId }) => session.sendControlLevel2(cmd, channel, accountId, payload, mValue3 ?? cmd), resolved ?? await this.resolveSession(sn, { waitLevel2: true, level2Sender }));
+    await this.replayLevel2Send(sn, `set-payload cmd ${cmd}`, ({ session, accountId, sendsClear }) => session.sendControlLevel2(cmd, channel, accountId, payload, mValue3 ?? cmd, sendsClear), resolved ?? await this.resolveSession(sn, { waitLevel2: true, level2Sender }));
   }
   /**
    * **`keyed-payload-actuate` intent** — the classic Wi-Fi lock's actuation: the sealed fields from
@@ -24093,7 +24142,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
    * bytes and never the routing channel — that's re-resolved here from the device record.
    */
   async sendFf09Actuate(sn, cmd) {
-    const resolved = await this.resolveSession(sn, { waitLevel2: true });
+    const resolved = await this.resolveSession(sn, { waitLevel2: true, clearFallback: true });
     const frame = buildFf09Frame({
       engage: cmd.engage,
       adminUserId: cmd.adminUserId,