@onekeyfe/hd-transport-react-native 1.2.0-alpha.9 → 1.2.0-alpha.91

package/dist/subscribeBleOn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscribeBleOn.d.ts","sourceRoot":"","sources":["../src/subscribeBleOn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,cAAc,eAAgB,aAAa,kBAAc,QAAQ,IAAI,CAqB9E,CAAC"}
+{"version":3,"file":"subscribeBleOn.d.ts","sourceRoot":"","sources":["../src/subscribeBleOn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,cAAc,eAAgB,aAAa,kBAAc,QAAQ,IAAI,CAmB9E,CAAC"}

package/dist/transportLog.d.ts

@@ -0,0 +1,2 @@
+export { createTransportCallLog } from '@onekeyfe/hd-transport';
+//# sourceMappingURL=transportLog.d.ts.map

package/dist/transportLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../src/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/types.d.ts

@@ -7,5 +7,6 @@ export type BleAcquireInput = {
     uuid: string;
     forceCleanRunPromise?: boolean;
     expectedProtocol?: ProtocolType;
+    protocolHint?: ProtocolType;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,YAAY,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;CACjC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,YAAY,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC"}

package/jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  preset: '../../jest.config.js',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['node_modules', '<rootDir>/dist'],
+  moduleNameMapper: {
+    // The workspace symlinks resolve to prebuilt dist outputs that can lag behind src.
+    '^@onekeyfe/hd-transport$': '<rootDir>/../hd-transport/src/index.ts',
+    '^@onekeyfe/hd-shared$': '<rootDir>/../shared/src/index.ts',
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.0-alpha.9",
+  "version": "1.2.0-alpha.91",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -15,15 +15,16 @@
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
     "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "test": "jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.0-alpha.9",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.9",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.9",
-    "@onekeyfe/react-native-ble-utils": "^0.1.4",
+    "@onekeyfe/hd-core": "1.2.0-alpha.91",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.91",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.91",
+    "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "f90ef9921b742f68cce9f4e7a0425e45e8ae7ec9"
+  "gitHead": "4a314a4b114a3aa01dd92e1d0a227e1c5ccbd4f3"
 }

package/src/BleTransport.ts

@@ -1,12 +1,5 @@
-import { BleErrorCode } from 'react-native-ble-plx';
-import { wait } from '@onekeyfe/hd-shared';
-
-import { bleLogger } from './logger';
-
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
 
-const Log = bleLogger;
-
 export default class BleTransport {
   id: string;
 
@@ -14,7 +7,7 @@ export default class BleTransport {
 
   device: Device;
 
-  mtuSize = 23;
+  mtuSize: number | undefined;
 
   writeCharacteristic: Characteristic;
 
@@ -28,10 +21,6 @@ export default class BleTransport {
 
   monitorToken?: number;
 
-  static MAX_RETRIES = 5;
-
-  static RETRY_DELAY = 2000;
-
   constructor(
     device: Device,
     writeCharacteristic: Characteristic,
@@ -44,36 +33,15 @@ export default class BleTransport {
   }
 
   /**
-   * @description only for pro / touch , while upgrade firmware
-   * @param data
-   * @param retryCount
-   * @returns
+   * Bulk-transfer write (Protocol V1 FirmwareUpload / EmmcFileWrite only).
+   *
+   * Must stay writeWithoutResponse on every platform. writeWithResponse serialises
+   * each packet into its own connection-interval round trip, which on iOS turned a
+   * 1.7MB firmware upload (~13.5k packets) into a >10 minute transfer that never
+   * finished before the app-level timeout. Protocol V2 and ordinary V1 control
+   * messages pick their write type separately and are unaffected by this method.
    */
-  async writeWithRetry(data: string, retryCount = BleTransport.MAX_RETRIES): Promise<void> {
-    try {
-      await this.writeCharacteristic.writeWithoutResponse(data);
-    } catch (error) {
-      Log?.debug(
-        `Write retry attempt ${BleTransport.MAX_RETRIES - retryCount + 1}, error: ${error}`
-      );
-      if (retryCount > 0) {
-        await wait(BleTransport.RETRY_DELAY);
-        if (
-          error.errorCode === BleErrorCode.DeviceDisconnected ||
-          error.errorCode === BleErrorCode.CharacteristicNotFound
-        ) {
-          try {
-            await this.device.connect();
-            await this.device.discoverAllServicesAndCharacteristics();
-          } catch (e) {
-            Log?.debug(`Connect or discoverAllServicesAndCharacteristics error: ${e}`);
-          }
-        } else {
-          Log?.debug(`writeCharacteristic error: ${error}`);
-        }
-        return this.writeWithRetry(data, retryCount - 1);
-      }
-      throw error;
-    }
+  async writeWithRetry(data: string): Promise<void> {
+    await this.writeCharacteristic.writeWithoutResponse(data);
   }
 }

package/src/__tests__/BleTransport.test.ts

@@ -0,0 +1,114 @@
+import { BleErrorCode } from 'react-native-ble-plx';
+import { Platform } from 'react-native';
+
+import BleTransport from '../BleTransport';
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'ios' },
+  }),
+  { virtual: true }
+);
+
+jest.mock(
+  'react-native-ble-plx',
+  () => ({
+    BleErrorCode: {
+      DeviceDisconnected: 205,
+      CharacteristicNotFound: 404,
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('@onekeyfe/hd-shared', () => ({
+  ...jest.requireActual('@onekeyfe/hd-shared'),
+  wait: jest.fn(() => Promise.resolve()),
+}));
+
+describe('BleTransport side-effecting writes', () => {
+  beforeEach(() => {
+    Platform.OS = 'ios';
+  });
+
+  test('does not reconnect or replay after the device disconnects', async () => {
+    const error = Object.assign(new Error('device disconnected'), {
+      errorCode: BleErrorCode.DeviceDisconnected,
+    });
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.reject(error)),
+    };
+    const device = {
+      id: 'classic-id',
+      connect: jest.fn(() => Promise.resolve()),
+      discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(device as any, writeCharacteristic as any, {} as any);
+
+    await expect(transport.writeWithRetry('payload')).rejects.toBe(error);
+
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(device.connect).not.toHaveBeenCalled();
+  });
+
+  test('keeps iOS bulk transfer on writeWithoutResponse even when the characteristic supports responses', async () => {
+    // writeWithResponse serialises every packet into its own connection-interval
+    // round trip. On a ~1.7MB firmware (~13.5k packets) that stalled the upload past
+    // the 600s app-level timeout, so bulk transfer must never opt into it.
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+
+  test('keeps Android Protocol V1 writes on writeWithoutResponse', async () => {
+    Platform.OS = 'android';
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+
+  test('uses writeWithoutResponse on iOS when the characteristic lacks response support', async () => {
+    const writeCharacteristic = {
+      isWritableWithResponse: false,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+});

package/src/__tests__/bleStrategy.test.ts

@@ -1,7 +1,8 @@
 import {
   hasWritableCapability,
-  resolveBleWriteMode,
   resolveProtocolV2PacketCapacity,
+  shouldRefreshNegotiatedMtu,
+  shouldWriteProtocolV2WithResponse,
 } from '../bleStrategy';
 
 describe('React Native BLE strategy', () => {
@@ -12,30 +13,54 @@ describe('React Native BLE strategy', () => {
     };
 
     expect(hasWritableCapability(characteristic)).toBe(true);
-    expect(resolveBleWriteMode(characteristic)).toBe('withoutResponse');
   });
 
-  test('falls back to Android default ATT payload when MTU is unavailable', () => {
+  test('uses the conservative ATT payload when MTU is unavailable', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'android',
-        androidPacketLength: 192,
         mtu: null,
       })
     ).toBe(20);
   });
 
+  test('only refreshes an unavailable or default MTU snapshot', () => {
+    expect(shouldRefreshNegotiatedMtu(undefined)).toBe(true);
+    expect(shouldRefreshNegotiatedMtu(23)).toBe(true);
+    expect(shouldRefreshNegotiatedMtu(185)).toBe(false);
+    expect(shouldRefreshNegotiatedMtu(247)).toBe(false);
+  });
+
   test('caps Android packet length by negotiated MTU payload', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'android',
-        androidPacketLength: 192,
+        androidPacketLength: 244,
         mtu: 100,
       })
     ).toBe(97);
   });
 
-  test('keeps iOS packet length controlled by tuning profile', () => {
+  test('keeps the default Android packet length within the validated ceiling', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'android',
+        mtu: 517,
+      })
+    ).toBe(244);
+  });
+
+  test('allows an explicit Android packet length override for validated experiments', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'android',
+        androidPacketLength: 514,
+        mtu: 517,
+      })
+    ).toBe(514);
+  });
+
+  test('caps iOS packet length by the system-negotiated write payload', () => {
     expect(
       resolveProtocolV2PacketCapacity({
         platform: 'ios',
@@ -44,4 +69,62 @@ describe('React Native BLE strategy', () => {
       })
     ).toBe(244);
   });
+
+  test('uses the reported iOS MTU without a compatibility fallback', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'ios',
+        iosPacketLength: 128,
+        mtu: 23,
+      })
+    ).toBe(20);
+  });
+
+  test('uses a smaller system-negotiated iOS write payload', () => {
+    expect(
+      resolveProtocolV2PacketCapacity({
+        platform: 'ios',
+        iosPacketLength: 244,
+        mtu: 185,
+      })
+    ).toBe(182);
+  });
+
+  test('uses withoutResponse for a high-volume write unless explicitly overridden', () => {
+    const characteristic = {
+      isWritableWithResponse: true,
+      isWritableWithoutResponse: true,
+    };
+
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highThroughput: true,
+        requestedWithResponse: false,
+        characteristic,
+      })
+    ).toBe(false);
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highThroughput: true,
+        requestedWithResponse: true,
+        characteristic,
+      })
+    ).toBe(true);
+  });
+
+  test('falls back to withResponse when withoutResponse is unavailable', () => {
+    expect(
+      shouldWriteProtocolV2WithResponse({
+        platform: 'ios',
+        highThroughput: true,
+        requestedWithResponse: false,
+        characteristic: {
+          isWritableWithResponse: true,
+          isWritableWithoutResponse: false,
+        },
+      })
+    ).toBe(true);
+  });
 });

package/src/__tests__/connectTimeout.test.ts

@@ -0,0 +1,292 @@
+import { EventEmitter } from 'events';
+import { BleErrorCode } from 'react-native-ble-plx';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
+  BLE_CONNECT_TIMEOUT_MS,
+  BLE_GATT_SETUP_TIMEOUT_MS,
+} from '../index';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
+    PermissionsAndroid: {
+      PERMISSIONS: {},
+      RESULTS: {},
+      request: jest.fn(),
+      requestMultiple: jest.fn(),
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { InvalidHandle: 1, UnlikelyError: 14 },
+  BleError: Error,
+  BleErrorCode: {
+    DeviceDisconnected: 201,
+    OperationStartFailed: 601,
+    DeviceMTUChangeFailed: 401,
+    OperationCancelled: 2,
+    OperationTimedOut: 3,
+    DeviceAlreadyConnected: 203,
+  },
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('@onekeyfe/react-native-ble-utils', () => ({
+  __esModule: true,
+  default: {
+    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
+    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
+    pairDevice: jest.fn(() => Promise.resolve()),
+  },
+}));
+
+const UUID = 'stalled-connect-device';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+async function advanceUntil(settled: () => boolean, totalMs: number, stepMs = 250) {
+  for (let elapsed = 0; elapsed < totalMs; elapsed += stepMs) {
+    jest.advanceTimersByTime(stepMs);
+    // eslint-disable-next-line no-await-in-loop
+    await flush();
+    if (settled()) return;
+  }
+  throw new Error(`fake timers exhausted after ${totalMs}ms before the connect settled`);
+}
+
+/** A device whose native connect() never settles — the observed iOS failure mode. */
+function createHarness(connectImpl: () => Promise<unknown>) {
+  const connect = jest.fn(connectImpl);
+  const writeCharacteristic = {
+    uuid: '00000002-0000-1000-8000-00805f9b34fb',
+    isWritableWithResponse: true,
+  };
+  const notifyCharacteristic = {
+    uuid: '00000003-0000-1000-8000-00805f9b34fb',
+    isNotifiable: true,
+  };
+  const device = {
+    id: UUID,
+    name: 'OneKey Classic',
+    localName: 'OneKey Classic',
+    serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+    isConnected: jest.fn(() => Promise.resolve(false)),
+    cancelConnection: jest.fn(() => Promise.resolve()),
+    connect,
+    discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+    characteristicsForService: jest.fn(() =>
+      Promise.resolve([writeCharacteristic, notifyCharacteristic])
+    ),
+    services: jest.fn(() => Promise.resolve([])),
+    onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+  };
+  const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+  const bleManager = {
+    devices: jest.fn(() => Promise.resolve([device])),
+    connectedDevices: jest.fn(() => Promise.resolve([])),
+    connectToDevice: jest.fn(connectImpl),
+    cancelTransaction: jest.fn(() => Promise.resolve()),
+    cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+    onStateChange: jest.fn((listener: (state: string) => void) => {
+      // Dispatch asynchronously: subscribeBleOn wires its own cleanup after
+      // registering, so a synchronous callback would run before it is ready.
+      setImmediate(() => listener('PoweredOn'));
+      return { remove: jest.fn() };
+    }),
+    state: jest.fn(() => Promise.resolve('PoweredOn')),
+    startDeviceScan: jest.fn(),
+    stopDeviceScan: jest.fn(),
+  };
+  (transport as any).blePlxManager = bleManager;
+  transport.init(
+    { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
+    new EventEmitter()
+  );
+  transport.configure(protocolV1Schema);
+  return { transport, device, bleManager, connect };
+}
+
+describe('BLE connect timeout', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('a native connect that never settles is bounded instead of blocking forever', async () => {
+    // iOS applies its own connect timeout on a serial queue; when that queue is busy
+    // the timeout never fires and acquire() blocks until the app-level 60s timeout.
+    const { transport } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    transport.acquire({ uuid: UUID }).catch(e => {
+      errors.push(e);
+      settled = true;
+    });
+    await flush();
+
+    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
+  });
+
+  test('the connect budget leaves generous headroom over a healthy connect', () => {
+    // Healthy connects finish in ~2-3s (the native budget is 3s); this backstop only
+    // fires when the native timeout itself fails to.
+    expect(BLE_CONNECT_TIMEOUT_MS).toBeGreaterThanOrEqual(6000);
+    expect(BLE_CONNECT_TIMEOUT_MS).toBeLessThanOrEqual(12000);
+  });
+
+  test('a stalled connect is abandoned natively so the next attempt is not cancelled by it', async () => {
+    const { transport, bleManager } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    let settled = false;
+    transport.acquire({ uuid: UUID }).catch(() => {
+      settled = true;
+    });
+    await flush();
+    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
+  test('repeated stalled connects recreate the BLE manager', async () => {
+    const { transport, bleManager } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+    const destroy = jest.fn();
+    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
+
+    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
+      let settled = false;
+      transport.acquire({ uuid: UUID }).catch(() => {
+        settled = true;
+      });
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      // eslint-disable-next-line no-await-in-loop
+      await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+    }
+
+    expect(destroy).toHaveBeenCalledTimes(1);
+    expect((transport as unknown as { blePlxManager?: unknown }).blePlxManager).toBeUndefined();
+  });
+
+  test('a recreated BLE manager starts with fresh timeout budgets for every device', () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    (bleManager as unknown as { destroy: jest.Mock }).destroy = jest.fn();
+    (transport as any).connectionSetupTimeoutCounts.set('setup-device', 1);
+    (transport as any).writeTimeoutCounts.set('write-device', 1);
+
+    (transport as any).resetPlxManager();
+
+    expect((transport as any).connectionSetupTimeoutCounts.size).toBe(0);
+    expect((transport as any).writeTimeoutCounts.size).toBe(0);
+  });
+
+  test('native connect timeouts contribute to the same manager reset budget', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const destroy = jest.fn();
+    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
+    const nativeTimeout = Object.assign(new Error('Operation timed out'), {
+      errorCode: BleErrorCode.OperationTimedOut,
+    });
+
+    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await expect(
+        (transport as any).connectWithTimeout(UUID, () => Promise.reject(nativeTimeout))
+      ).rejects.toBe(nativeTimeout);
+    }
+
+    expect(destroy).toHaveBeenCalledTimes(1);
+  });
+
+  test('GATT discovery is bounded and abandons the native connection', async () => {
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
+    device.discoverAllServicesAndCharacteristics.mockImplementation(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch((error: unknown) => {
+      errors.push(error as { errorCode?: unknown });
+      settled = true;
+    });
+    await flush();
+    await advanceUntil(() => settled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
+  test('a successful GATT retry clears the timeout budget before an abandoned call settles', async () => {
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
+    let resolveAbandonedDiscovery: (() => void) | undefined;
+    device.discoverAllServicesAndCharacteristics
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>(resolve => {
+            resolveAbandonedDiscovery = resolve;
+          })
+      )
+      .mockResolvedValueOnce(undefined);
+
+    let firstSettled = false;
+    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch(() => {
+      firstSettled = true;
+    });
+    await flush();
+    await advanceUntil(() => firstSettled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
+
+    await expect(
+      (transport as any).resolveCharacteristicsWithTimeout(UUID, device)
+    ).resolves.toMatchObject({
+      writeCharacteristic: expect.any(Object),
+      notifyCharacteristic: expect.any(Object),
+    });
+
+    resolveAbandonedDiscovery?.();
+    await flush();
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledTimes(1);
+    expect((transport as any).connectionSetupTimeoutCounts.has(UUID)).toBe(false);
+  });
+});