@onekeyfe/hd-transport-web-device 1.2.0-alpha.16 → 1.2.0-alpha.161

package/src/electron-ble-transport.ts

@@ -1,26 +1,34 @@
 import transport, {
   PROTOCOL_V1_MESSAGE_HEADER_SIZE,
+  PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
   PROTOCOL_V2_CHANNEL_BLE_UART,
   ProtocolV2FrameAssembler,
   ProtocolV2LinkManager,
+  TRANSPORT_EVENT,
   bytesToHex,
   hexToBytes,
   probeProtocolV2 as probeProtocolV2Helper,
+  writeProtocolV2BleFrame,
 } from '@onekeyfe/hd-transport';
 import {
+  EBleDisconnectReason,
   ERRORS,
   HardwareErrorCode,
   HardwareErrorCodeMessage,
   createDeferred,
   isHeaderChunk,
-  wait,
 } from '@onekeyfe/hd-shared';
 
-import { createTransportCallLog, shouldSuppressHighVolumeCallLog } from './transportLog';
+import { resolveBlePacketCapacity } from './ble-packet-capacity';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { DesktopAPI } from '@onekeyfe/hd-transport-electron';
-import type { OneKeyDeviceInfo, ProtocolType, TransportCallOptions } from '@onekeyfe/hd-transport';
+import type {
+  OneKeyDeviceInfo,
+  ProtocolType,
+  ProtocolV2CallContext,
+  TransportCallOptions,
+} from '@onekeyfe/hd-transport';
 import type EventEmitter from 'events';
 
 const { parseConfigure, ProtocolV1, check } = transport;
@@ -35,6 +43,7 @@ export type BleAcquireInput = {
   uuid: string;
   forceCleanRunPromise?: boolean;
   expectedProtocol?: ProtocolType;
+  protocolHint?: ProtocolType;
 };
 
 interface PacketProcessResult {
@@ -43,10 +52,6 @@ interface PacketProcessResult {
   error?: string;
 }
 
-function inferProtocolHintFromDeviceName(name?: string | null): ProtocolType | undefined {
-  return /\bpro\s*2\b/i.test(name ?? '') ? 'V2' : undefined;
-}
-
 const toBleDescriptor = (
   device: { id: string; name: string | null },
   protocolType?: ProtocolType
@@ -60,29 +65,33 @@ const toBleDescriptor = (
     ...(protocolType ? { protocolType } : {}),
   } as OneKeyDeviceInfo);
 
-const BLE_PACKET_SIZE = 192;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAXIMUM = 244;
 const BLE_WRITE_DELAY_MS = 5;
-const BLE_RESPONSE_TIMEOUT_MS = 30_000;
-const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
+const PROTOCOL_PROBE_TIMEOUT_MS = 3000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
 
 /**
  * Desktop Electron BLE transport with automatic Protocol V1/V2 detection.
  *
  * Protocol V1 devices continue using chunked packets. Protocol V2 is detected
- * after a Protocol V1 Initialize timeout by probing Protocol V2 Ping.
+ * after a Protocol V1 GetFeatures timeout by probing Protocol V2 Ping.
  */
 export default class ElectronBleTransport {
   private _messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
   private _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  private protocolV2SchemaConfiguration: string | undefined;
+
   name = 'ElectronBleTransport';
 
   configured = false;
 
   runPromise: Deferred<Uint8Array | string> | null = null;
 
+  private runPromiseDeviceId: string | null = null;
+
   Log?: any;
 
   emitter?: EventEmitter;
@@ -93,6 +102,13 @@ export default class ElectronBleTransport {
 
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
+  /** Endpoints that answered a V2 probe in this transport lifetime. Survives disconnect. */
+  private confirmedProtocolV2 = new Set<string>();
+
+  private deviceMtus: Map<string, number> = new Map();
+
+  private devicePacketCapacities: Map<string, number> = new Map();
+
   private v1Buffers: Map<string, { buffer: number[]; bufferLength: number }> = new Map();
 
   private v2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
@@ -117,14 +133,27 @@ export default class ElectronBleTransport {
       this.rejectProtocolV2Frames(uuid, new Error(reason));
       this.Log?.debug('[Electron BLE] Protocol V2 link invalidated:', uuid, reason);
       if (reason.startsWith('Protocol V2 link-fatal error:')) {
-        await this.release(uuid);
+        await this.releaseNative(uuid);
       }
     },
   });
 
+  /** One-shot guard so a missing preload `release` bridge is reported once. */
+  private warnedMissingRelease = false;
+
   private notificationCleanups: Map<string, () => void> = new Map();
 
-  private disconnectCleanups: Map<string, () => void> = new Map();
+  private mtuCleanups: Map<string, () => void> = new Map();
+
+  /**
+   * Transport-lifetime subscription to host BLE disconnects.
+   *
+   * This must NOT be scoped to acquire()/release(): a logical release keeps the
+   * native link alive for the keep-alive window, so a device that drops while
+   * idle would otherwise go unobserved and consumers would never learn it left
+   * (OK-60486).
+   */
+  private hostDisconnectCleanup?: () => void;
 
   private notificationTokens: Map<string, number> = new Map();
 
@@ -167,12 +196,19 @@ export default class ElectronBleTransport {
       .catch(error => this.Log?.debug('[Electron BLE] link cleanup failed:', error));
     this.connectedDevices.delete(deviceId);
     this.deviceProtocol.delete(deviceId);
+    this.deviceMtus.delete(deviceId);
+    this.devicePacketCapacities.delete(deviceId);
     // Keep deviceProtocolHints — it's inferred from device name (e.g. "Pro 2" → V2)
     // and doesn't depend on connection state. Preserving it avoids redundant V1 probe on reconnect.
     this.v1Buffers.delete(deviceId);
     this.v2Assemblers.delete(deviceId);
     this.resetProtocolV2Frames(deviceId);
     this.notificationTokens.delete(deviceId);
+    if (this.runPromise && this.runPromiseDeviceId === deviceId) {
+      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
+      this.runPromise = null;
+      this.runPromiseDeviceId = null;
+    }
 
     const notifyCleanup = this.notificationCleanups.get(deviceId);
     if (notifyCleanup) {
@@ -180,10 +216,10 @@ export default class ElectronBleTransport {
       this.notificationCleanups.delete(deviceId);
     }
 
-    const disconnectCleanup = this.disconnectCleanups.get(deviceId);
-    if (disconnectCleanup) {
-      disconnectCleanup();
-      this.disconnectCleanups.delete(deviceId);
+    const mtuCleanup = this.mtuCleanups.get(deviceId);
+    if (mtuCleanup) {
+      mtuCleanup();
+      this.mtuCleanups.delete(deviceId);
     }
   }
 
@@ -198,19 +234,67 @@ export default class ElectronBleTransport {
       );
     }
 
+    this.subscribeHostDisconnects();
+
     this.Log?.debug('[Electron BLE] Transport initialized');
   }
 
+  /**
+   * One host subscription for the whole transport lifetime. init() can run
+   * again after an SDK reset, so drop the previous listener first rather than
+   * stacking duplicates.
+   */
+  private subscribeHostDisconnects() {
+    this.hostDisconnectCleanup?.();
+    this.hostDisconnectCleanup = window.desktopApi?.nobleBle?.onDeviceDisconnected(
+      (disconnectedDevice: { id: string; name: string; reason?: EBleDisconnectReason }) => {
+        const uuid = disconnectedDevice?.id;
+        if (!uuid) return;
+
+        // The link is gone, so renderer-side state must go with it; the next
+        // acquire reconnects from scratch.
+        this.cleanupDeviceState(uuid);
+
+        // Every link drop is reported, including the main process reclaiming
+        // an idle link on its keep-alive timer: consumers track whether a BLE
+        // link is live, not whether the peripheral is theoretically in range,
+        // and a link we closed ourselves is still a closed link. Nothing
+        // reconnects on its own, so this settles once until the user acts.
+        // `reason` is carried for diagnostics only — behaviour is uniform.
+        this.Log?.debug(
+          '[Electron BLE] Device link dropped:',
+          uuid,
+          disconnectedDevice.reason ?? EBleDisconnectReason.DeviceDisconnected
+        );
+
+        this.emitter?.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+          name: disconnectedDevice.name,
+          id: uuid,
+          connectId: uuid,
+        });
+      }
+    );
+  }
+
   configure(signedData: any) {
     this._messages = parseConfigure(signedData);
     this.configured = true;
   }
 
   configureProtocolV2(signedData: any) {
+    const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+    if (this.protocolV2SchemaConfiguration === configuration) {
+      return;
+    }
+
+    const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
     this._messagesV2 = parseConfigure(signedData);
-    this.protocolV2Links
-      .invalidateAllLinks('Protocol V2 schema reconfigured')
-      .catch(error => this.Log?.debug('[Electron BLE] schema link cleanup failed:', error));
+    this.protocolV2SchemaConfiguration = configuration;
+    if (isReconfiguration) {
+      this.protocolV2Links
+        .invalidateAllLinks('Protocol V2 schema reconfigured')
+        .catch(error => this.Log?.debug('[Electron BLE] schema link cleanup failed:', error));
+    }
   }
 
   async listen() {
@@ -226,10 +310,6 @@ export default class ElectronBleTransport {
       this.Log?.debug(`[Electron BLE] enumerate found ${devices.length} device(s):`);
       for (const dev of devices) {
         this.Log?.debug(`[Electron BLE]   id="${dev.id}" name="${dev.name}"`);
-        const protocolHint = inferProtocolHintFromDeviceName(dev.name);
-        if (protocolHint) {
-          this.deviceProtocolHints.set(dev.id, protocolHint);
-        }
       }
       return devices.map(device => toBleDescriptor(device));
     } catch (error) {
@@ -252,8 +332,8 @@ export default class ElectronBleTransport {
     if (forceCleanRunPromise && this.runPromise) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
       this.runPromise = null;
+      this.runPromiseDeviceId = null;
     }
 
     try {
@@ -267,7 +347,7 @@ export default class ElectronBleTransport {
       }
       const protocolHint = expectedProtocol
         ? undefined
-        : this.deviceProtocolHints.get(uuid) ?? inferProtocolHintFromDeviceName(device.name);
+        : input.protocolHint ?? this.deviceProtocolHints.get(uuid);
       if (protocolHint) {
         this.deviceProtocolHints.set(uuid, protocolHint);
       }
@@ -279,35 +359,28 @@ export default class ElectronBleTransport {
         this.handleBluetoothError(error);
       }
 
+      const mtuCleanup = this.createMtuSubscription(uuid);
+      if (mtuCleanup) {
+        this.mtuCleanups.set(uuid, mtuCleanup);
+      }
+
       this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
-      this.v2Assemblers.set(uuid, new ProtocolV2FrameAssembler());
+      this.v2Assemblers.set(uuid, new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
 
       await window.desktopApi.nobleBle.subscribe(uuid);
+      await this.refreshBlePacketCapacity(uuid);
 
       const cleanup = this.createNotificationSubscription(uuid);
       this.notificationCleanups.set(uuid, cleanup);
 
-      const disconnectCleanup = window.desktopApi.nobleBle.onDeviceDisconnected(
-        (disconnectedDevice: any) => {
-          if (disconnectedDevice.id === uuid) {
-            this.cleanupDeviceState(uuid);
-            this.emitter?.emit('device-disconnect', {
-              name: disconnectedDevice.name,
-              id: disconnectedDevice.id,
-              connectId: disconnectedDevice.id,
-            });
-          }
-        }
-      );
-      this.disconnectCleanups.set(uuid, disconnectCleanup);
-
       const protocolType = await this.detectProtocol(uuid, expectedProtocol, protocolHint);
-
-      this.emitter?.emit('device-connect', {
-        name: device.name,
-        id: device.id,
-        connectId: device.id,
-      });
+      if (protocolType === 'V2') {
+        this.Log?.debug('[Electron BLE] Protocol V2 write configured', {
+          writeMode: 'withoutResponse',
+          negotiatedMtu: this.deviceMtus.get(uuid),
+          packetCapacity: this.devicePacketCapacities.get(uuid) ?? BLE_PACKET_SIZE_FALLBACK,
+        });
+      }
 
       return {
         ...toBleDescriptor({ id: device.id, name: device.name }, protocolType),
@@ -328,9 +401,25 @@ export default class ElectronBleTransport {
     }
   }
 
-  async release(id: string) {
+  async release(id: string, _onclose?: boolean, keepSession?: boolean) {
     try {
       await this.protocolV2Links.invalidateLink(id, 'Electron BLE transport released');
+      await this.releaseLogical(id, keepSession);
+    } catch (error) {
+      this.Log?.error('[Electron BLE] release failed:', error);
+      this.cleanupDeviceState(id);
+    }
+  }
+
+  // DeviceConnector.disconnect feature-detects this; without it REQUIRE_DISCONNECT
+  // recovery is a no-op and keep-alive hands the wedged link to every retry.
+  async disconnect(id: string) {
+    return this.releaseNative(id);
+  }
+
+  // Hard teardown, error paths only: a link presumed dead must not be reused.
+  private async releaseNative(id: string) {
+    try {
       if (this.connectedDevices.has(id)) {
         if (window.desktopApi?.nobleBle) {
           await window.desktopApi.nobleBle.unsubscribe(id);
@@ -344,9 +433,38 @@ export default class ElectronBleTransport {
     }
   }
 
-  private createProtocolMismatchError(expected: ProtocolType) {
+  // Logical release: link and subscription stay up for the next call. Renderer
+  // listeners are still torn down, or fresh ones would double-process packets.
+  private async releaseLogical(id: string, keepSession?: boolean) {
+    try {
+      if (!this.connectedDevices.has(id)) return;
+      this.cleanupDeviceState(id);
+
+      const release = window.desktopApi?.nobleBle?.release;
+      if (!release) {
+        // Degraded, not broken: say it once, it just looks like a slow device.
+        if (!this.warnedMissingRelease) {
+          this.warnedMissingRelease = true;
+          this.Log?.error(
+            '[Electron BLE] desktopApi.nobleBle.release is missing from the preload bridge; ' +
+              'keep-alive idle countdown will never start — map NOBLE_BLE_RELEASE in the desktop preload'
+          );
+        }
+        return;
+      }
+      await release(id, keepSession);
+    } catch (error) {
+      this.Log?.error('[Electron BLE] logical release failed:', error);
+      this.cleanupDeviceState(id);
+    }
+  }
+
+  private createProtocolMismatchError(expected: ProtocolType, uuid: string) {
+    // A generic Ping miss is not a bond failure. Only a later miss after this
+    // endpoint already answered V2, or a native encryption/pairing error, is.
+    const isStaleV2Bond = expected === 'V2' && this.confirmedProtocolV2.has(uuid);
     return ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
+      isStaleV2Bond ? HardwareErrorCode.BleDeviceBondError : HardwareErrorCode.RuntimeError,
       `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
     );
   }
@@ -354,7 +472,7 @@ export default class ElectronBleTransport {
   private createProtocolDetectionError() {
     return ERRORS.TypedError(
       HardwareErrorCode.BleTimeoutError,
-      'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+      'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping'
     );
   }
 
@@ -375,33 +493,38 @@ export default class ElectronBleTransport {
         this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V1 (expected)`);
         return 'V1';
       }
-      throw this.createProtocolMismatchError(expectedProtocol);
+      throw this.createProtocolMismatchError(expectedProtocol, uuid);
     }
 
     if (expectedProtocol === 'V2') {
-      // 免探测路径：调用方显式承诺该设备是 V2（例如固件升级重启后的重连场景，
-      // 上层已经探测过协议并通过 expectedProtocol 传回），这里不再重复探测。
-      this.deviceProtocol.set(uuid, 'V2');
-      this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
-      return 'V2';
+      if (await this.probeProtocolV2(uuid)) {
+        this.deviceProtocol.set(uuid, 'V2');
+        this.confirmedProtocolV2.add(uuid);
+        this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+        return 'V2';
+      }
+      throw this.createProtocolMismatchError(expectedProtocol, uuid);
     }
 
-    // 项目约束：协议判断必须在连接后主动探测，不能依赖设备名/PID/descriptor。
-    // 设备名 hint（如 "Pro 2"）只用于调整探测顺序：hint=V2 时先探 V2、失败回落 V1，
-    // 不能作为最终结论。
+    // Protocol must be actively probed after connection. Name, PID, and descriptors only
+    // influence probe order; a V2 hint probes V2 first and falls back to V1.
     const probeOrder: ProtocolType[] =
       protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
 
     for (let i = 0; i < probeOrder.length; i += 1) {
       const protocol = probeOrder[i];
       if (i > 0) {
-        // 上一个协议探测失败后，重置订阅与缓冲，避免残留数据干扰下一个协议的探测。
+        // Keep the physical BLE link while switching probes. Reconnecting here can
+        // summon a second OS pairing prompt for a device that is still onboarding.
         await this.resetProbeStateAfterProtocolProbe(uuid, probeOrder[i - 1]);
       }
       const detected =
         protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
       if (detected) {
         this.deviceProtocol.set(uuid, protocol);
+        if (protocol === 'V2') {
+          this.confirmedProtocolV2.add(uuid);
+        }
         this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> ${protocol}`);
         return protocol;
       }
@@ -435,33 +558,20 @@ export default class ElectronBleTransport {
     this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
     this.v2Assemblers.get(uuid)?.reset();
     this.resetProtocolV2Frames(uuid);
-    if (this.runPromise) {
+    if (this.runPromise && this.runPromiseDeviceId === uuid) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
       this.runPromise = null;
+      this.runPromiseDeviceId = null;
     }
 
-    const notifyCleanup = this.notificationCleanups.get(uuid);
-    if (notifyCleanup) {
-      notifyCleanup();
-      this.notificationCleanups.delete(uuid);
-    }
-    this.notificationTokens.delete(uuid);
-
-    try {
-      await window.desktopApi?.nobleBle?.unsubscribe(uuid);
-    } catch (error) {
-      this.Log?.debug(`[Electron BLE] unsubscribe after Protocol ${protocol} probe failed:`, error);
-    }
-    try {
-      await window.desktopApi?.nobleBle?.subscribe(uuid);
-    } catch (error) {
-      this.Log?.debug(`[Electron BLE] resubscribe after Protocol ${protocol} probe failed:`, error);
-      throw error;
+    // A timed-out V1 probe retires its renderer notification token so a late V1
+    // response cannot satisfy the V2 probe. Install a fresh listener without
+    // touching the native GATT subscription or physical connection.
+    if (!this.notificationCleanups.has(uuid)) {
+      const cleanup = this.createNotificationSubscription(uuid);
+      this.notificationCleanups.set(uuid, cleanup);
     }
-
-    const cleanup = this.createNotificationSubscription(uuid);
-    this.notificationCleanups.set(uuid, cleanup);
   }
 
   private async probeProtocolV1(uuid: string) {
@@ -471,11 +581,13 @@ export default class ElectronBleTransport {
 
     try {
       this.deviceProtocol.set(uuid, 'V1');
-      await this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+      // GetFeatures identifies Protocol V1 without resetting an existing wallet
+      // session before Core has a chance to restore a hidden wallet.
+      await this.callProtocolV1(uuid, 'GetFeatures', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
       return true;
     } catch (error) {
       this.clearProbeProtocol(uuid, 'V1');
-      this.Log?.debug('[Electron BLE] Protocol V1 Initialize probe failed:', error);
+      this.Log?.debug('[Electron BLE] Protocol V1 GetFeatures probe failed:', error);
       return false;
     }
   }
@@ -503,35 +615,63 @@ export default class ElectronBleTransport {
     return detected;
   }
 
-  private async writeWithChunking(uuid: string, hexData: string): Promise<void> {
-    const totalBytes = hexData.length / 2;
-
-    if (totalBytes <= BLE_PACKET_SIZE) {
-      await wait(BLE_WRITE_DELAY_MS);
-      await this.writeOnce(uuid, hexData);
-      return;
+  private async writeOnce(uuid: string, hexData: string): Promise<void> {
+    const nobleBle = window.desktopApi?.nobleBle;
+    if (!nobleBle) {
+      throw new Error('Noble BLE API not available');
     }
 
-    for (let offset = 0; offset < hexData.length; ) {
-      const chunkHexLen = Math.min(BLE_PACKET_SIZE * 2, hexData.length - offset);
-      const chunkHex = hexData.substring(offset, offset + chunkHexLen);
-      offset += chunkHexLen;
+    await nobleBle.write(uuid, hexData, { pacingDelayMs: 0 });
+  }
 
-      await this.writeOnce(uuid, chunkHex);
+  private async refreshBlePacketCapacity(uuid: string): Promise<void> {
+    const device = await window.desktopApi?.nobleBle?.getDevice(uuid);
+    this.updateBlePacketCapacity(uuid, device?.mtu);
+  }
 
-      if (offset < hexData.length) {
-        await wait(BLE_WRITE_DELAY_MS);
-      }
+  private updateBlePacketCapacity(uuid: string, mtu?: number): void {
+    const packetCapacity = resolveBlePacketCapacity(
+      mtu,
+      BLE_PACKET_SIZE_MAXIMUM,
+      BLE_PACKET_SIZE_FALLBACK
+    );
+    if (typeof mtu === 'number') {
+      this.deviceMtus.set(uuid, mtu);
+    } else {
+      this.deviceMtus.delete(uuid);
     }
+    this.devicePacketCapacities.set(uuid, packetCapacity);
   }
 
-  private async writeOnce(uuid: string, hexData: string): Promise<void> {
-    const nobleBle = window.desktopApi?.nobleBle;
-    if (!nobleBle) {
-      throw new Error('Noble BLE API not available');
-    }
+  private createMtuSubscription(uuid: string): (() => void) | undefined {
+    const onMtuChanged = window.desktopApi?.nobleBle?.onMtuChanged;
+    if (!onMtuChanged) return undefined;
+    return onMtuChanged(device => {
+      if (device.id === uuid) {
+        this.updateBlePacketCapacity(uuid, device.mtu);
+      }
+    });
+  }
 
-    await nobleBle.write(uuid, hexData);
+  private writeProtocolV2Frame(
+    uuid: string,
+    frame: Uint8Array,
+    context: ProtocolV2CallContext,
+    assertCurrentGeneration: () => void
+  ) {
+    const packetCapacity = this.devicePacketCapacities.get(uuid) ?? BLE_PACKET_SIZE_FALLBACK;
+    const shouldPace = !context.highThroughput;
+    return writeProtocolV2BleFrame({
+      frame,
+      packetCapacity,
+      assertActive: assertCurrentGeneration,
+      signal: context.signal,
+      abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+      initialDelayMs: shouldPace && frame.length <= packetCapacity ? BLE_WRITE_DELAY_MS : 0,
+      burstSize: shouldPace ? 1 : undefined,
+      burstPauseMs: shouldPace ? BLE_WRITE_DELAY_MS : 0,
+      writePacket: packet => this.writeOnce(uuid, bytesToHex(packet)),
+    });
   }
 
   private handleNotification(deviceId: string, hexData: string): void {
@@ -540,7 +680,7 @@ export default class ElectronBleTransport {
       const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceBondedCanceled);
       if (this.deviceProtocol.get(deviceId) === 'V2') {
         this.rejectProtocolV2Frames(deviceId, error);
-      } else if (this.runPromise) {
+      } else if (this.runPromise && this.runPromiseDeviceId === deviceId) {
         this.runPromise.reject(error);
       }
       return;
@@ -595,17 +735,8 @@ export default class ElectronBleTransport {
     this.getProtocolV2FrameQueue(uuid).push(frame);
   }
 
-  private rejectAllProtocolV2Frames(error: Error) {
-    this.v2FrameQueues.clear();
-    for (const framePromise of this.v2FramePromises.values()) {
-      framePromise.reject(error);
-    }
-    this.v2FramePromises.clear();
-  }
-
   private resetProtocolV2Frames(uuid: string) {
-    this.v2FrameQueues.delete(uuid);
-    this.v2FramePromises.delete(uuid);
+    this.rejectProtocolV2Frames(uuid, new Error(`Protocol V2 frame state reset for ${uuid}`));
   }
 
   private rejectProtocolV2Frames(uuid: string, error: Error) {
@@ -639,13 +770,18 @@ export default class ElectronBleTransport {
 
     if (result.error) {
       this.Log?.error('[Electron BLE] Protocol V1 packet processing error:', result.error);
-      if (this.runPromise) {
+      if (this.runPromise && this.runPromiseDeviceId === deviceId) {
         this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError));
       }
       return;
     }
 
-    if (result.isComplete && result.completePacket && this.runPromise) {
+    if (
+      result.isComplete &&
+      result.completePacket &&
+      this.runPromise &&
+      this.runPromiseDeviceId === deviceId
+    ) {
       this.runPromise.resolve(result.completePacket);
     }
   }
@@ -671,16 +807,25 @@ export default class ElectronBleTransport {
         `Device protocol has not been detected for ${uuid}`
       );
     }
-    if (!shouldSuppressHighVolumeCallLog(name)) {
-      this.Log?.debug('transport call', createTransportCallLog(name, protocol));
-    }
-
     if (protocol === 'V2') {
       return this.callProtocolV2(uuid, name, data, options);
     }
     return this.callProtocolV1(uuid, name, data, options);
   }
 
+  async post(uuid: string, name: string, data: Record<string, unknown>) {
+    if (this.deviceProtocol.get(uuid) === 'V2') {
+      await this.protocolV2Links.sendFlowControl(
+        uuid,
+        () => this.createProtocolV2Adapter(uuid),
+        name,
+        data
+      );
+      return;
+    }
+    await this.callProtocolV1(uuid, name, data);
+  }
+
   private async callProtocolV1(
     uuid: string,
     name: string,
@@ -699,6 +844,7 @@ export default class ElectronBleTransport {
     const runPromise = createDeferred<Uint8Array | string>();
     runPromise.promise.catch(() => undefined);
     this.runPromise = runPromise;
+    this.runPromiseDeviceId = uuid;
     const messages = this._messages;
     const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
     let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -743,11 +889,24 @@ export default class ElectronBleTransport {
       return check.call(jsonData);
     } catch (e) {
       this.Log?.error('[Electron BLE] Protocol V1 call error:', e);
+      const isProbeTimeout =
+        name === 'GetFeatures' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS;
+      if ((e as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleTimeoutError) {
+        this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
+        const notifyCleanup = this.notificationCleanups.get(uuid);
+        notifyCleanup?.();
+        this.notificationCleanups.delete(uuid);
+        this.notificationTokens.delete(uuid);
+        if (!isProbeTimeout) {
+          await this.releaseNative(uuid);
+        }
+      }
       throw e;
     } finally {
       if (timeout) clearTimeout(timeout);
       if (this.runPromise === runPromise) {
         this.runPromise = null;
+        this.runPromiseDeviceId = null;
       }
     }
   }
@@ -762,10 +921,7 @@ export default class ElectronBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const callOptions = {
-      ...options,
-      timeoutMs: options?.timeoutMs ?? BLE_RESPONSE_TIMEOUT_MS,
-    };
+    const callOptions = options;
 
     try {
       return await this.protocolV2Links.call(
@@ -791,16 +947,15 @@ export default class ElectronBleTransport {
 
     return {
       router: PROTOCOL_V2_CHANNEL_BLE_UART,
+      maxFrameBytes: PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
       generation,
       prepareCall: () => {
         assertCurrentGeneration();
         this.v2Assemblers.get(uuid)?.reset();
         this.resetProtocolV2Frames(uuid);
       },
-      writeFrame: (frame: Uint8Array) => {
-        assertCurrentGeneration();
-        return this.writeWithChunking(uuid, bytesToHex(frame));
-      },
+      writeFrame: (frame: Uint8Array, context: ProtocolV2CallContext) =>
+        this.writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration),
       readFrame: async () => {
         assertCurrentGeneration();
         const rxFrame = await this.readProtocolV2Frame(uuid);
@@ -844,6 +999,12 @@ export default class ElectronBleTransport {
         bufferState.bufferLength = dataView.getInt32(5, false);
         bufferState.buffer = [...data.subarray(3)];
       } else {
+        if (bufferState.buffer.length === 0) {
+          // Tail of a cancelled call, arriving after the buffer was reset. Not an
+          // `error`: the caller rejects the in-flight call on that field.
+          this.Log?.debug('[Electron BLE] Orphan continuation chunk discarded');
+          return { isComplete: false };
+        }
         bufferState.buffer = bufferState.buffer.concat([...data]);
       }