@onekeyfe/hd-transport-react-native 1.2.3-alpha.1 → 1.2.3-alpha.11

package/dist/index.js

@@ -57,36 +57,73 @@ const bleLogger = {
 };
 
 const Logger = bleLogger;
+const bondFailureReasons = {
+    1: 'authentication_failed',
+    2: 'rejected',
+    3: 'canceled',
+    4: 'device_unreachable',
+    5: 'discovery_in_progress',
+    6: 'timeout',
+    7: 'repeated_attempts',
+    8: 'remote_canceled',
+    9: 'removed',
+};
 const getConnectedDeviceIds = (serviceUuids) => BleUtils__default["default"].getConnectedPeripherals(serviceUuids);
 const pairDevice = (macAddress) => BleUtils__default["default"].pairDevice(macAddress);
-const onDeviceBondState = (bleMacAddress) => new Promise((resolve, reject) => {
+const onDeviceBondState = (bleMacAddress, signal) => new Promise((resolve, reject) => {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+        return;
+    }
     const cleanup = () => {
         if (timeout) {
             clearTimeout(timeout);
         }
         if (cleanupListener)
             cleanupListener();
+        signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => {
+        cleanup();
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
     };
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
     const timeout = setTimeout(() => {
         cleanup();
-        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded'));
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', {
+            phase: 'bond',
+            reason: 'timeout',
+        }));
     }, 60 * 1000);
     const cleanupListener = BleUtils__default["default"].onDeviceBondState(peripheral => {
-        var _a;
+        var _a, _b;
         if (((_a = peripheral.id) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== bleMacAddress.toLowerCase()) {
             return;
         }
         const { bondState } = peripheral;
         const hasBonded = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_BONDED';
-        const hasCanceled = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
+        const hasFailed = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
         Logger.debug('onDeviceBondState bondState:', bondState);
         if (hasBonded) {
             cleanup();
             resolve(peripheral);
         }
-        else if (hasCanceled) {
+        else if (hasFailed) {
             cleanup();
-            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'bonding canceled'));
+            const nativeReason = 'reason' in bondState && typeof bondState.reason === 'number'
+                ? bondState.reason
+                : undefined;
+            const reason = nativeReason === undefined ? 'unknown' : (_b = bondFailureReasons[nativeReason]) !== null && _b !== void 0 ? _b : 'unknown';
+            const params = Object.assign({ phase: 'bond', reason }, (nativeReason === undefined ? {} : { nativeReason }));
+            if (reason === 'timeout') {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', params));
+            }
+            else if (reason === 'canceled') {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'Bluetooth pairing canceled', params));
+            }
+            else {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed', params));
+            }
         }
     });
 });
@@ -194,6 +231,27 @@ const subscribeBleOn = (bleManager, ms = 1000) => new Promise((resolve, reject)
     }, ms);
 });
 
+const BLE_PLX_DEVICE_DISCONNECTED = 201;
+const IOS_PERIPHERAL_DISCONNECTED = 7;
+const nativeErrorText$1 = (error) => [error.reason, error.message]
+    .filter((value) => typeof value === 'string')
+    .join(' ');
+const isNativeBleDisconnectError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const nativeError = error;
+    return (nativeError.errorCode === BLE_PLX_DEVICE_DISCONNECTED ||
+        nativeError.iosErrorCode === IOS_PERIPHERAL_DISCONNECTED);
+};
+const toBleDisconnectHardwareError = (error) => {
+    if ((error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleDeviceDisconnected) {
+        return error;
+    }
+    const nativeError = (error !== null && error !== void 0 ? error : {});
+    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, nativeErrorText$1(nativeError) || undefined);
+};
+
 const ATT_INSUFFICIENT_AUTHENTICATION = 5;
 const ATT_INSUFFICIENT_ENCRYPTION = 15;
 const IOS_PEER_REMOVED_PAIRING_INFORMATION = 14;
@@ -258,6 +316,7 @@ class BleTransport {
 const { check, ProtocolV1, parseConfigure } = transport__default["default"];
 const Log = bleLogger;
 const transportCache = {};
+let bleManagerResetPromise;
 const FIRMWARE_UPLOAD_WRITE_BURST_SIZE = reactNative.Platform.OS === 'ios' ? 4 : 5;
 const FIRMWARE_UPLOAD_WRITE_PAUSE_MS = reactNative.Platform.OS === 'ios' ? 8 : 10;
 const FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS = reactNative.Platform.OS === 'ios' ? 24 : 30;
@@ -316,6 +375,43 @@ const WEDGED_WRITE_MESSAGE = 'BLE write timeout after';
 const isWedgedWriteError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleWriteCharacteristicError &&
     typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' &&
     error.message.startsWith(WEDGED_WRITE_MESSAGE);
+const shouldRethrowProtocolProbeError = (error) => {
+    const code = error === null || error === void 0 ? void 0 : error.errorCode;
+    return (hdShared.isBleStaleBondHardwareError(error) ||
+        isNativeBleDisconnectError(error) ||
+        code === hdShared.HardwareErrorCode.BleDeviceNotBonded ||
+        code === hdShared.HardwareErrorCode.BleDeviceBondedCanceled ||
+        code === hdShared.HardwareErrorCode.BleDeviceDisconnected ||
+        code === hdShared.HardwareErrorCode.BleCharacteristicNotifyError ||
+        code === hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure ||
+        code === hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+};
+const logIosBleBondDiagnostic = (phase, error, outcome) => {
+    if (reactNative.Platform.OS !== 'ios')
+        return;
+    const nativeError = (error !== null && error !== void 0 ? error : {});
+    const scalar = (value) => typeof value === 'string' || typeof value === 'number' ? value : undefined;
+    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] probe error', {
+        phase,
+        outcome,
+        errorName: scalar(nativeError.name),
+        errorCode: scalar(nativeError.errorCode),
+        attErrorCode: scalar(nativeError.attErrorCode),
+        iosErrorCode: scalar(nativeError.iosErrorCode),
+        androidErrorCode: scalar(nativeError.androidErrorCode),
+        nativeStaleBond: isNativeBleStaleBondError(error),
+        hardwareStaleBond: hdShared.isBleStaleBondHardwareError(error),
+        nativeDisconnect: isNativeBleDisconnectError(error),
+    });
+};
+const isIosProbeDisconnectError = (error) => {
+    if (reactNative.Platform.OS !== 'ios')
+        return false;
+    const code = error === null || error === void 0 ? void 0 : error.errorCode;
+    return (isNativeBleDisconnectError(error) ||
+        code === hdShared.HardwareErrorCode.BleDeviceNotBonded ||
+        code === hdShared.HardwareErrorCode.BleDeviceDisconnected);
+};
 const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
@@ -350,10 +446,10 @@ function getDeviceDisplayName(device) {
 }
 const IOS_REQUEST_MTU = 247;
 const ANDROID_REQUEST_MTU = 517;
-const BLE_MTU_REFRESH_RETRY_DELAY_MS = 200;
 const ANDROID_HIGH_PRIORITY_IDLE_MS = 1000;
 const getRequestedBleMtu = () => reactNative.Platform.OS === 'android' ? ANDROID_REQUEST_MTU : IOS_REQUEST_MTU;
 const BLE_NATIVE_CONNECT_TIMEOUT_MS = 3000;
+const BLE_MTU_REQUEST_TIMEOUT_MS = BLE_NATIVE_CONNECT_TIMEOUT_MS;
 const connectOptions = {
     requestMTU: getRequestedBleMtu(),
     timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
@@ -362,6 +458,29 @@ const connectOptions = {
 const fallbackConnectOptions = {
     timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
 };
+const androidRefreshGattConnectOptions = {
+    timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
+    refreshGatt: 'OnConnected',
+};
+const ANDROID_MTU_EXCHANGE_TIMEOUT_MS = 12000;
+const ANDROID_LINK_DROP_QUIET_MS = 5000;
+const ANDROID_LINK_DROP_POLL_MS = 250;
+const isKnownDefaultMtu = (mtu) => typeof mtu === 'number' && Number.isFinite(mtu) && mtu <= 23;
+const isMissingGattShapeError = (error) => {
+    const code = error === null || error === void 0 ? void 0 : error.errorCode;
+    const message = error === null || error === void 0 ? void 0 : error.message;
+    return (code === hdShared.HardwareErrorCode.BleServiceNotFound ||
+        code === hdShared.HardwareErrorCode.BleCharacteristicNotFound ||
+        (typeof message === 'string' &&
+            (message.includes('BLECharacteristicNotFound') ||
+                message.includes('BLECharacteristicNotWritable') ||
+                message.includes('BLECharacteristicNotNotifiable'))));
+};
+const isStaleGattTableNotifyReason = (reason) => !!reason &&
+    (reason.includes('Cannot write client characteristic config descriptor') ||
+        reason.includes('Cannot find client characteristic config descriptor') ||
+        reason.includes('The handle is invalid') ||
+        reason.includes('Writing is not permitted'));
 const BLE_CONNECT_TIMEOUT_MS = BLE_NATIVE_CONNECT_TIMEOUT_MS * 2 + 2000;
 const BLE_GATT_SETUP_TIMEOUT_MS = 10000;
 const PROTOCOL_REPROBE_FALLBACK_ATTEMPTS = 3;
@@ -376,6 +495,11 @@ const isWedgedBleSetupError = (error) => (error === null || error === void 0 ? v
     error.message.startsWith(BLE_SETUP_WEDGED_MESSAGE);
 const shouldRethrowBleSetupError = (error) => isConnectTimeoutError(error) || isWedgedBleSetupError(error);
 const isNativeOperationTimeoutError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === reactNativeBlePlx.BleErrorCode.OperationTimedOut;
+const isMtuOrCancelledConnectError = (error) => {
+    const errorCode = error === null || error === void 0 ? void 0 : error.errorCode;
+    return (errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+        errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled);
+};
 const tryToGetConfiguration = (device) => {
     if (!device || !device.serviceUUIDs)
         return null;
@@ -387,25 +511,65 @@ const tryToGetConfiguration = (device) => {
         return null;
     return infos;
 };
-const requestNegotiatedMtu = (device, stage, attempt) => __awaiter(void 0, void 0, void 0, function* () {
+const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __awaiter(void 0, void 0, void 0, function* () {
     if (reactNative.Platform.OS !== 'ios' && reactNative.Platform.OS !== 'android')
-        return device;
+        return { device, timedOut: false };
+    const transactionId = `${device.id}:mtu:${stage}:${attempt}:${Date.now()}`;
+    let timeoutId;
+    let timedOut = false;
     try {
-        const mtuDevice = yield device.requestMTU(getRequestedBleMtu());
-        return mtuDevice;
+        const request = device.requestMTU(getRequestedBleMtu(), transactionId);
+        request.catch(() => undefined);
+        const mtuDevice = yield Promise.race([
+            request,
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    timedOut = true;
+                    reject(new Error(`BLE MTU request timeout after ${BLE_MTU_REQUEST_TIMEOUT_MS}ms`));
+                }, BLE_MTU_REQUEST_TIMEOUT_MS);
+            }),
+        ]);
+        return { device: mtuDevice, timedOut: false };
     }
     catch (error) {
+        if (timedOut && cancelTransaction) {
+            try {
+                Promise.resolve(cancelTransaction(transactionId)).catch(cancelError => {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU cancellation failed', {
+                        platform: reactNative.Platform.OS,
+                        stage,
+                        attempt,
+                        error: cancelError instanceof Error ? cancelError.message : String(cancelError),
+                    });
+                });
+            }
+            catch (cancelError) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU cancellation failed', {
+                    platform: reactNative.Platform.OS,
+                    stage,
+                    attempt,
+                    error: cancelError instanceof Error ? cancelError.message : String(cancelError),
+                });
+            }
+        }
         Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU refresh failed, continuing with current value', {
             platform: reactNative.Platform.OS,
             stage,
             attempt,
             actual: device.mtu,
+            timedOut,
             error: error instanceof Error ? error.message : String(error),
         });
-        return device;
+        return { device, timedOut };
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
     }
 });
-const resolveNegotiatedMtu = (device) => requestNegotiatedMtu(device, 'connected', 0);
+const resolveNegotiatedMtu = (device, cancelTransaction) => shouldRefreshNegotiatedMtu(device.mtu)
+    ? requestNegotiatedMtu(device, 'connected', 0, cancelTransaction)
+    : Promise.resolve({ device, timedOut: false });
 function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
@@ -429,6 +593,7 @@ class ReactNativeBleTransport {
         this.name = 'ReactNativeBleTransport';
         this.configured = false;
         this.stopped = false;
+        this.bondAbortController = new AbortController();
         this.scanTimeout = DEVICE_SCAN_TIMEOUT_MS;
         this.runPromise = null;
         this.runPromiseDeviceId = null;
@@ -441,6 +606,9 @@ class ReactNativeBleTransport {
         this.sessionProtocols = new Map();
         this.confirmedProtocolV2 = new Set();
         this.protocolReprobeFailures = new Map();
+        this.silentDetections = new Map();
+        this.iosProbeDisconnectEvidence = new Map();
+        this.androidGattCacheRefreshes = new Set();
         this.staleBondErrors = new Map();
         this.acquiringProtocolV2 = new Set();
         this.protocolV2Assemblers = new Map();
@@ -458,11 +626,20 @@ class ReactNativeBleTransport {
             },
             classifyError: () => 'link-fatal',
             onLinkInvalidated: (uuid, reason) => __awaiter(this, void 0, void 0, function* () {
-                var _b;
+                var _b, _c;
                 (_b = this.protocolV2Assemblers.get(uuid)) === null || _b === void 0 ? void 0 : _b.reset();
                 this.rejectProtocolV2Frames(uuid, new Error(reason));
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 link invalidated:', uuid, reason);
                 if (reason.startsWith('Protocol V2 link-fatal error:')) {
+                    if (this.probingProtocols.get(uuid) !== 'V2') {
+                        const transport = transportCache[uuid];
+                        try {
+                            this.emitDeviceDisconnect(uuid, (_c = transport === null || transport === void 0 ? void 0 : transport.device) === null || _c === void 0 ? void 0 : _c.name, transport === null || transport === void 0 ? void 0 : transport.monitorToken);
+                        }
+                        catch (_d) {
+                            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] Protocol V2 disconnect listener failed');
+                        }
+                    }
                     yield this.releaseNative(uuid, true);
                 }
             }),
@@ -474,6 +651,7 @@ class ReactNativeBleTransport {
         this.androidPriorityResetTimers = new Map();
         this.nextMonitorToken = 1;
         this.lifecycleOperations = new Map();
+        this.scanCleanups = new Set();
         this.scanTimeout = (_a = options.scanTimeout) !== null && _a !== void 0 ? _a : DEVICE_SCAN_TIMEOUT_MS;
     }
     init(logger, emitter) {
@@ -502,10 +680,38 @@ class ReactNativeBleTransport {
     listen() {
     }
     getPlxManager() {
-        if (this.blePlxManager)
-            return Promise.resolve(this.blePlxManager);
-        this.blePlxManager = new reactNativeBlePlx.BleManager();
-        return Promise.resolve(this.blePlxManager);
+        return __awaiter(this, void 0, void 0, function* () {
+            while (bleManagerResetPromise) {
+                yield this.waitForManagerReset();
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (!this.blePlxManager)
+                this.blePlxManager = new reactNativeBlePlx.BleManager();
+            return this.blePlxManager;
+        });
+    }
+    waitForManagerReset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!bleManagerResetPromise)
+                return;
+            let timeout;
+            try {
+                yield Promise.race([
+                    bleManagerResetPromise,
+                    new Promise((_, reject) => {
+                        timeout = setTimeout(() => reject(this.createWedgedBleSetupError()), BLE_CONNECT_TIMEOUT_MS);
+                    }),
+                ]);
+            }
+            catch (_a) {
+                throw this.createWedgedBleSetupError();
+            }
+            finally {
+                if (timeout)
+                    clearTimeout(timeout);
+            }
+        });
     }
     resolveCharacteristics(device) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -670,30 +876,55 @@ class ReactNativeBleTransport {
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                const deviceList = [];
-                const blePlxManager = yield this.getPlxManager();
-                try {
-                    yield subscribeBleOn(blePlxManager);
-                }
-                catch (error) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('subscribeBleOn error: ', error);
-                    reject(error);
-                    return;
-                }
-                if (reactNative.Platform.OS === 'android' && reactNative.Platform.Version >= 31) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, please wait...');
-                    const resultConnect = yield reactNative.PermissionsAndroid.requestMultiple([
-                        reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
-                        reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
-                    ]);
-                    Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, result: ', resultConnect);
-                    if (resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT] !== 'granted' ||
-                        resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN] !== 'granted') {
-                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
-                        return;
-                    }
+            const scanStartedAt = Date.now();
+            let firstDeviceMs;
+            const blePlxManager = yield this.getPlxManager();
+            yield subscribeBleOn(blePlxManager);
+            if (reactNative.Platform.OS === 'android' && reactNative.Platform.Version >= 31) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, please wait...');
+                const resultConnect = yield reactNative.PermissionsAndroid.requestMultiple([
+                    reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT,
+                    reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN,
+                ]);
+                Log === null || Log === void 0 ? void 0 : Log.debug('requesting permissions, result: ', resultConnect);
+                if (resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_CONNECT] !== 'granted' ||
+                    resultConnect[reactNative.PermissionsAndroid.PERMISSIONS.BLUETOOTH_SCAN] !== 'granted') {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
                 }
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            return new Promise((resolve, reject) => {
+                const deviceList = [];
+                let finished = false;
+                let scanCleanup;
+                const finishScan = (error) => {
+                    if (scanCleanup)
+                        return scanCleanup;
+                    finished = true;
+                    clearScanTimer();
+                    scanCleanup = this.runNativeTeardown('scan', blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield blePlxManager.stopDeviceScan();
+                    })).then(() => {
+                        this.scanCleanups.delete(cancelScan);
+                        if (error)
+                            reject(error);
+                        else
+                            resolve(deviceList);
+                    });
+                    return scanCleanup;
+                };
+                const cancelScan = () => finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+                this.scanCleanups.add(cancelScan);
+                const clearScanTimer = timer.timeout(() => {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] scan completed', {
+                        elapsedMs: Date.now() - scanStartedAt,
+                        firstDeviceMs,
+                        deviceCount: deviceList.length,
+                        scanWindowMs: this.scanTimeout,
+                    });
+                    finishScan();
+                }, this.scanTimeout);
                 blePlxManager.startDeviceScan(getBluetoothServiceUuids(), {
                     allowDuplicates: true,
                     scanMode: reactNativeBlePlx.ScanMode.LowLatency,
@@ -702,19 +933,17 @@ class ReactNativeBleTransport {
                     if (error) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('ble scan error: ', error);
                         if ([reactNativeBlePlx.BleErrorCode.BluetoothPoweredOff, reactNativeBlePlx.BleErrorCode.BluetoothInUnknownState].includes(error.errorCode)) {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
                         }
                         else if (error.errorCode === reactNativeBlePlx.BleErrorCode.BluetoothUnauthorized) {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError));
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError));
                         }
                         else if (error.errorCode === reactNativeBlePlx.BleErrorCode.LocationServicesDisabled) {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationServicesDisabled));
-                        }
-                        else if (error.errorCode === reactNativeBlePlx.BleErrorCode.ScanStartFailed) {
-                            timer.timeout(() => { }, this.scanTimeout);
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationServicesDisabled));
                         }
+                        else if (error.errorCode === reactNativeBlePlx.BleErrorCode.ScanStartFailed) ;
                         else {
-                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, (_a = error.reason) !== null && _a !== void 0 ? _a : ''));
+                            finishScan(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, (_a = error.reason) !== null && _a !== void 0 ? _a : ''));
                         }
                         return;
                     }
@@ -739,6 +968,8 @@ class ReactNativeBleTransport {
                         });
                     }
                 });
+                if (finished)
+                    return;
                 getConnectedDeviceIds(reactNative.Platform.OS === 'ios' ? getBluetoothServiceUuids() : []).then(devices => {
                     for (const device of devices) {
                         const localName = 'localName' in device && typeof device.localName === 'string'
@@ -754,10 +985,11 @@ class ReactNativeBleTransport {
                             addDevice(device);
                         }
                     }
-                });
+                }, error => Log === null || Log === void 0 ? void 0 : Log.debug('search connected peripheral failed:', error));
                 const addDevice = (device) => {
                     var _a;
-                    if (deviceList.every(d => d.id !== device.id)) {
+                    if (!finished && deviceList.every(d => d.id !== device.id)) {
+                        firstDeviceMs !== null && firstDeviceMs !== void 0 ? firstDeviceMs : (firstDeviceMs = Date.now() - scanStartedAt);
                         const displayName = (_a = getDeviceDisplayName(device)) !== null && _a !== void 0 ? _a : 'Unknown BLE Device';
                         deviceList.push(Object.assign(Object.assign({}, device), { name: displayName, commType: 'ble' }));
                         Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] OneKey BLE device discovered', {
@@ -767,16 +999,14 @@ class ReactNativeBleTransport {
                         });
                     }
                 };
-                timer.timeout(() => {
-                    blePlxManager.stopDeviceScan();
-                    resolve(deviceList);
-                }, this.scanTimeout);
-            }));
+            });
         });
     }
     installTransportForAcquire(uuid, device, characteristics) {
         return __awaiter(this, void 0, void 0, function* () {
             const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristicsWithTimeout(uuid, device));
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
             transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : undefined;
             const monitorToken = this.nextMonitorToken;
@@ -797,30 +1027,12 @@ class ReactNativeBleTransport {
             else if (reactNative.Platform.OS === 'android') {
                 yield delay(ANDROID_NOTIFY_READY_DELAY_MS);
             }
-            const initialMtu = transport$1.mtuSize;
-            let refreshAttempts = 0;
-            if ((reactNative.Platform.OS === 'ios' || reactNative.Platform.OS === 'android') &&
-                shouldRefreshNegotiatedMtu(transport$1.mtuSize)) {
-                refreshAttempts += 1;
-                let refreshedDevice = yield requestNegotiatedMtu(transport$1.device, 'servicesAndNotifyReady', 1);
-                transport$1.device = refreshedDevice;
-                transport$1.mtuSize =
-                    typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport$1.mtuSize;
-                if (shouldRefreshNegotiatedMtu(transport$1.mtuSize)) {
-                    yield delay(BLE_MTU_REFRESH_RETRY_DELAY_MS);
-                    refreshAttempts += 1;
-                    refreshedDevice = yield requestNegotiatedMtu(transport$1.device, 'servicesAndNotifyReady', 2);
-                    transport$1.device = refreshedDevice;
-                    transport$1.mtuSize =
-                        typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport$1.mtuSize;
-                }
-            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE MTU ready', {
                 platform: reactNative.Platform.OS,
                 requested: getRequestedBleMtu(),
-                initial: initialMtu,
                 actual: transport$1.mtuSize,
-                refreshAttempts,
             });
             return transport$1;
         });
@@ -837,6 +1049,8 @@ class ReactNativeBleTransport {
     acquireUnlocked(input) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const { uuid, forceCleanRunPromise, expectedProtocol, skipProtocolProbe } = input;
             const shouldMapProtocolV2StaleBond = expectedProtocol
                 ? expectedProtocol === 'V2'
@@ -868,9 +1082,13 @@ class ReactNativeBleTransport {
                     const isCachedDeviceConnected = yield cachedTransport.device
                         .isConnected()
                         .catch(() => false);
+                    const isCachedAndroidLinkUsable = reactNative.Platform.OS !== 'android' || !this.androidGattCacheRefreshes.has(uuid);
                     if (isCachedDeviceConnected &&
+                        isCachedAndroidLinkUsable &&
                         cachedProtocol &&
                         (!expectedProtocol || cachedProtocol === expectedProtocol)) {
+                        if (this.stopped)
+                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
                         Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
                         return { uuid, protocolType: cachedProtocol };
                     }
@@ -879,6 +1097,15 @@ class ReactNativeBleTransport {
                 }
             }
             let device = null;
+            const isAndroid = reactNative.Platform.OS === 'android';
+            const refreshAndroidGattCache = isAndroid && (!!skipProtocolProbe || this.androidGattCacheRefreshes.has(uuid));
+            let nativeConnectOptions = connectOptions;
+            if (isAndroid) {
+                nativeConnectOptions = refreshAndroidGattCache
+                    ? androidRefreshGattConnectOptions
+                    : fallbackConnectOptions;
+            }
+            let androidRefreshConnectRan = false;
             if (forceCleanRunPromise && this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
@@ -887,6 +1114,7 @@ class ReactNativeBleTransport {
                 Log === null || Log === void 0 ? void 0 : Log.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
             }
             const blePlxManager = yield this.getPlxManager();
+            let skipPostConnectMtu = false;
             try {
                 yield subscribeBleOn(blePlxManager);
             }
@@ -894,6 +1122,27 @@ class ReactNativeBleTransport {
                 Log === null || Log === void 0 ? void 0 : Log.debug('subscribeBleOn error: ', error);
                 throw error;
             }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (reactNative.Platform.OS === 'android') {
+                try {
+                    const bondState = yield pairDevice(uuid);
+                    if (bondState.bonding) {
+                        yield onDeviceBondState(uuid, this.bondAbortController.signal);
+                    }
+                    else if (!bondState.bonded) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
+                    }
+                }
+                catch (error) {
+                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.runBestEffortNativeOperation('bond failure: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid));
+                    }));
+                    throw error;
+                }
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             if (!device) {
                 const devices = yield blePlxManager.devices([uuid]);
                 [device] = devices;
@@ -907,15 +1156,16 @@ class ReactNativeBleTransport {
             if (!device) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device: ', uuid);
                 try {
-                    device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, connectOptions));
+                    device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, nativeConnectOptions));
+                    androidRefreshConnectRan = refreshAndroidGattCache;
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device has error: ', e);
                     if (shouldRethrowBleSetupError(e)) {
                         throw e;
                     }
-                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
-                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
+                    if (isMtuOrCancelledConnectError(e)) {
+                        skipPostConnectMtu = true;
                         Log === null || Log === void 0 ? void 0 : Log.debug('first try to reconnect without params');
                         device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, fallbackConnectOptions));
                     }
@@ -931,19 +1181,27 @@ class ReactNativeBleTransport {
             if (!device) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'unable to connect to device');
             }
+            if (refreshAndroidGattCache &&
+                !androidRefreshConnectRan &&
+                (yield device.isConnected().catch(() => false))) {
+                yield this.dropAndroidLink(uuid, blePlxManager, device, 'gatt cache refresh');
+                if (this.stopped)
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            }
             if (!(yield device.isConnected())) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device: ', uuid);
                 const disconnectedDevice = device;
                 try {
-                    device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(connectOptions));
+                    device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(nativeConnectOptions));
+                    androidRefreshConnectRan = refreshAndroidGattCache;
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device has error: ', e);
                     if (shouldRethrowBleSetupError(e)) {
                         throw e;
                     }
-                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
-                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
+                    if (isMtuOrCancelledConnectError(e)) {
+                        skipPostConnectMtu = true;
                         Log === null || Log === void 0 ? void 0 : Log.debug('second try to reconnect without params');
                         try {
                             device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
@@ -965,33 +1223,70 @@ class ReactNativeBleTransport {
                     }
                 }
             }
-            if (reactNative.Platform.OS === 'android') {
-                const connectedDevice = device;
-                try {
-                    if (!(yield connectedDevice.isConnected().catch(() => false))) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Device ${uuid} is not connected before bonding`);
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (reactNative.Platform.OS === 'android' && !(yield device.isConnected().catch(() => false))) {
+                const disconnectedDevice = device;
+                yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                    yield Promise.all([
+                        this.runBestEffortNativeOperation('connect failure: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid)),
+                        this.runBestEffortNativeOperation('connect failure: cancel device connection', () => disconnectedDevice.cancelConnection()),
+                    ]);
+                }));
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'device is not connected');
+            }
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            let characteristics;
+            if (isAndroid) {
+                if (refreshAndroidGattCache) {
+                    characteristics = yield this.resolveCharacteristicsWithTimeout(uuid, device);
+                    if (androidRefreshConnectRan)
+                        this.androidGattCacheRefreshes.delete(uuid);
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                }
+                device = yield this.negotiateAndroidMtu(uuid, blePlxManager, device);
+            }
+            else if (!skipPostConnectMtu) {
+                const mtuResult = yield resolveNegotiatedMtu(device, transactionId => blePlxManager.cancelTransaction(transactionId));
+                device = mtuResult.device;
+                if (mtuResult.timedOut) {
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] post-connect MTU timed out, reconnecting without requesting MTU');
+                    const timedOutDevice = device;
+                    let mtuTeardownSettled = false;
+                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.runBestEffortNativeOperation('mtu timeout: cancel device connection', () => timedOutDevice.cancelConnection());
+                        mtuTeardownSettled = true;
+                    }));
+                    if (this.stopped)
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+                    if (!mtuTeardownSettled || this.blePlxManager !== blePlxManager) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'BLE MTU cleanup timed out');
                     }
-                    const bondState = yield pairDevice(uuid);
-                    if (bondState.bonding) {
-                        yield onDeviceBondState(uuid);
+                    try {
+                        device = yield this.connectWithTimeout(uuid, () => timedOutDevice.connect(fallbackConnectOptions));
                     }
-                    else if (!bondState.bonded) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
+                    catch (error) {
+                        if (shouldRethrowBleSetupError(error))
+                            throw error;
+                        if ((error === null || error === void 0 ? void 0 : error.errorCode) === reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
+                            device = timedOutDevice;
+                        }
+                        else {
+                            remapError(error);
+                        }
                     }
                 }
-                catch (error) {
-                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
-                        yield Promise.all([
-                            this.runBestEffortNativeOperation('bond failure: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid)),
-                            this.runBestEffortNativeOperation('bond failure: cancel device connection', () => connectedDevice.cancelConnection()),
-                        ]);
-                    }));
-                    throw error;
-                }
             }
-            device = yield resolveNegotiatedMtu(device);
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const acquiredDevice = device;
-            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice);
+            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice));
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             const protocolHint = expectedProtocol
                 ? undefined
                 : (_a = input.protocolHint) !== null && _a !== void 0 ? _a : this.deviceProtocolHints.get(uuid);
@@ -1034,6 +1329,8 @@ class ReactNativeBleTransport {
                 const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint, () => __awaiter(this, void 0, void 0, function* () {
                     yield this.installTransportForAcquire(uuid, acquiredDevice);
                 }));
+                if (this.stopped)
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
                 const currentTransport = transportCache[uuid];
                 if (!currentTransport) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
@@ -1042,12 +1339,9 @@ class ReactNativeBleTransport {
                 return { uuid, protocolType };
             }
             catch (error) {
-                if (hdShared.isBleStaleBondHardwareError(error)) {
-                    yield this.disconnectUnlocked(uuid);
-                }
-                else {
-                    yield this.releaseUnlocked(uuid, true);
-                }
+                yield this.disconnectUnlocked(uuid, {
+                    preserveIosProbeDisconnect: this.iosProbeDisconnectEvidence.has(uuid),
+                });
                 throw error;
             }
             finally {
@@ -1059,7 +1353,7 @@ class ReactNativeBleTransport {
         let bufferLength = 0;
         let buffer$1 = [];
         const subscription = characteristic.monitor((error, c) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            var _a, _b, _c, _d, _e, _f;
             const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
             if (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug(`error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${error}`);
@@ -1076,16 +1370,16 @@ class ReactNativeBleTransport {
                     this.rememberStaleBondError(uuid, toBleStaleBondHardwareError(error));
                     return;
                 }
+                if (reactNative.Platform.OS === 'android' && isStaleGattTableNotifyReason(error.reason)) {
+                    this.androidGattCacheRefreshes.add(uuid);
+                }
                 if (this.getActiveProtocol(uuid) === 'V2') {
                     let errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
                     if ((_a = error.reason) === null || _a === void 0 ? void 0 : _a.includes('The connection has timed out unexpectedly')) {
                         errorCode = hdShared.HardwareErrorCode.BleTimeoutError;
                     }
-                    else if (((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('Cannot write client characteristic config descriptor')) ||
-                        ((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('Cannot find client characteristic config descriptor')) ||
-                        ((_d = error.reason) === null || _d === void 0 ? void 0 : _d.includes('The handle is invalid')) ||
-                        ((_e = error.reason) === null || _e === void 0 ? void 0 : _e.includes('Writing is not permitted')) ||
-                        ((_f = error.reason) === null || _f === void 0 ? void 0 : _f.includes('notify change failed for device'))) {
+                    else if (isStaleGattTableNotifyReason(error.reason) ||
+                        ((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('notify change failed for device'))) {
                         errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
                     }
                     this.rejectProtocolV2Frames(uuid, hdShared.ERRORS.TypedError(errorCode));
@@ -1093,14 +1387,11 @@ class ReactNativeBleTransport {
                 }
                 if (this.runPromise && this.runPromiseDeviceId === uuid) {
                     let ERROR = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
-                    if ((_g = error.reason) === null || _g === void 0 ? void 0 : _g.includes('The connection has timed out unexpectedly')) {
+                    if ((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('The connection has timed out unexpectedly')) {
                         ERROR = hdShared.HardwareErrorCode.BleTimeoutError;
                     }
-                    if (((_h = error.reason) === null || _h === void 0 ? void 0 : _h.includes('Cannot write client characteristic config descriptor')) ||
-                        ((_j = error.reason) === null || _j === void 0 ? void 0 : _j.includes('Cannot find client characteristic config descriptor')) ||
-                        ((_k = error.reason) === null || _k === void 0 ? void 0 : _k.includes('The handle is invalid')) ||
-                        ((_l = error.reason) === null || _l === void 0 ? void 0 : _l.includes('Writing is not permitted')) ||
-                        ((_m = error.reason) === null || _m === void 0 ? void 0 : _m.includes('notify change failed for device'))) {
+                    if (isStaleGattTableNotifyReason(error.reason) ||
+                        ((_d = error.reason) === null || _d === void 0 ? void 0 : _d.includes('notify change failed for device'))) {
                         const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
                         this.runPromise.reject(notifyError);
                         Log === null || Log === void 0 ? void 0 : Log.debug(`${hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`);
@@ -1142,7 +1433,7 @@ class ReactNativeBleTransport {
                     bufferLength = 0;
                     buffer$1 = [];
                     if (this.runPromiseDeviceId === uuid) {
-                        (_o = this.runPromise) === null || _o === void 0 ? void 0 : _o.resolve(value.toString('hex'));
+                        (_e = this.runPromise) === null || _e === void 0 ? void 0 : _e.resolve(value.toString('hex'));
                     }
                 }
             }
@@ -1153,7 +1444,7 @@ class ReactNativeBleTransport {
                     this.rejectProtocolV2Frames(uuid, notifyError);
                 }
                 else if (this.runPromiseDeviceId === uuid) {
-                    (_p = this.runPromise) === null || _p === void 0 ? void 0 : _p.reject(notifyError);
+                    (_f = this.runPromise) === null || _f === void 0 ? void 0 : _f.reject(notifyError);
                 }
             }
         }, notifyTransactionId);
@@ -1429,13 +1720,14 @@ class ReactNativeBleTransport {
                 return check.call(jsonData);
             }
             catch (e) {
-                if (name === 'GetFeatures' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe call failed:', e);
+                const isProbeTimeout = (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS &&
+                    (name === 'GetFeatures' || name === 'Initialize');
+                if (isProbeTimeout) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] Protocol V1 ${name} probe call failed:`, e);
                 }
                 else {
                     Log === null || Log === void 0 ? void 0 : Log.error('call error: ', e);
                 }
-                const isProbeTimeout = name === 'GetFeatures' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS;
                 const isStaleCall = this.runPromise !== runPromise;
                 if (!isProbeTimeout &&
                     !isStaleCall &&
@@ -1455,14 +1747,51 @@ class ReactNativeBleTransport {
         });
     }
     stop() {
+        var _a;
+        if (this.stopPromise)
+            return this.stopPromise;
         this.stopped = true;
+        this.bondAbortController.abort();
+        const deviceIds = new Set([
+            ...this.monitorTokens.keys(),
+            ...this.sessionProtocols.keys(),
+            ...this.lifecycleOperations.keys(),
+            ...(this.runPromiseDeviceId ? [this.runPromiseDeviceId] : []),
+        ]);
+        const scans = Array.from(this.scanCleanups, cleanup => cleanup());
+        this.androidPriorityResetTimers.forEach(timeout => clearTimeout(timeout));
+        this.androidPriorityResetTimers.clear();
+        this.androidHighPriorityDevices.clear();
+        this.iosProbeDisconnectEvidence.clear();
+        const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+        (_a = this.runPromise) === null || _a === void 0 ? void 0 : _a.reject(error);
+        this.runPromise = null;
+        this.runPromiseDeviceId = null;
+        deviceIds.forEach(uuid => this.rejectProtocolV2Frames(uuid, error));
+        const manager = this.blePlxManager;
+        const pendingConnections = manager
+            ? Array.from(this.lifecycleOperations.keys(), uuid => this.runNativeTeardown(uuid, manager, () => __awaiter(this, void 0, void 0, function* () {
+                yield this.runBestEffortNativeOperation('stop: cancel pending device connection', () => manager.cancelDeviceConnection(uuid));
+            })))
+            : [];
+        this.stopPromise = Promise.all([
+            ...scans,
+            ...pendingConnections,
+            ...Array.from(deviceIds, uuid => this.disconnect(uuid)),
+        ]).then(() => __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2Links.invalidateAllLinks('React Native BLE transport stopped');
+            yield this.waitForManagerReset();
+            this.blePlxManager = undefined;
+            this.emitter = undefined;
+        }));
+        return this.stopPromise;
     }
     disconnect(session) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.runLifecycleOperation(session, () => this.disconnectUnlocked(session));
         });
     }
-    disconnectUnlocked(session) {
+    disconnectUnlocked(session, options) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.protocolV2Links.invalidateLink(session, 'React Native BLE transport disconnected');
@@ -1498,6 +1827,9 @@ class ReactNativeBleTransport {
             this.deviceProtocolHints.delete(session);
             this.sessionProtocols.delete(session);
             this.protocolReprobeFailures.delete(session);
+            if (!(options === null || options === void 0 ? void 0 : options.preserveIosProbeDisconnect)) {
+                this.iosProbeDisconnectEvidence.delete(session);
+            }
             this.protocolV2Assemblers.delete(session);
             this.resetProtocolV2Frames(session);
             try {
@@ -1585,13 +1917,93 @@ class ReactNativeBleTransport {
         });
     }
     cancel() {
-        Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native transport cancel');
-        if (this.runPromise) ;
-        this.runPromise = null;
-        this.runPromiseDeviceId = null;
+        return __awaiter(this, void 0, void 0, function* () {
+            Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native transport cancel');
+            const pending = this.runPromise;
+            const deviceId = this.runPromiseDeviceId;
+            if (pending) {
+                pending.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled));
+                if (this.runPromise === pending) {
+                    this.runPromise = null;
+                    this.runPromiseDeviceId = null;
+                }
+                if (deviceId)
+                    yield this.disconnect(deviceId);
+            }
+        });
+    }
+    negotiateAndroidMtu(uuid, manager, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!shouldRefreshNegotiatedMtu(device.mtu))
+                return device;
+            const startedAt = Date.now();
+            let timer;
+            let timedOut = false;
+            let negotiated = device;
+            let failure;
+            try {
+                negotiated = yield Promise.race([
+                    device.requestMTU(ANDROID_REQUEST_MTU, `${device.id}:mtu:connected:0:${startedAt}`),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(new Error(`BLE MTU exchange timeout after ${ANDROID_MTU_EXCHANGE_TIMEOUT_MS}ms`));
+                        }, ANDROID_MTU_EXCHANGE_TIMEOUT_MS);
+                    }),
+                ]);
+            }
+            catch (error) {
+                failure = error instanceof Error ? error.message : String(error);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+            Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] BLE MTU exchange ${failure ? 'failed' : 'completed'}`, {
+                connectIdSuffix: uuid.slice(-8),
+                elapsedMs: Date.now() - startedAt,
+                timedOut,
+                actual: negotiated.mtu,
+                error: failure,
+            });
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            if (!timedOut && !isKnownDefaultMtu(negotiated.mtu))
+                return negotiated;
+            const resetManager = this.abandonStalledConnection(uuid, timedOut ? 'mtu-backstop' : 'mtu-default');
+            yield this.dropAndroidLink(uuid, manager, negotiated, timedOut ? 'mtu exchange timeout' : 'default mtu');
+            if (resetManager)
+                throw this.createWedgedBleSetupError();
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, timedOut
+                ? 'BLE MTU exchange did not complete, reconnecting on a fresh link'
+                : `BLE link stayed at the default MTU ${negotiated.mtu}, reconnecting on a fresh link`);
+        });
+    }
+    dropAndroidLink(uuid, manager, device, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.runNativeTeardown(uuid, manager, () => __awaiter(this, void 0, void 0, function* () {
+                yield Promise.all([
+                    this.runBestEffortNativeOperation(`${reason}: cancel manager connection`, () => manager.cancelDeviceConnection(uuid)),
+                    this.runBestEffortNativeOperation(`${reason}: cancel device connection`, () => device.cancelConnection()),
+                ]);
+            }));
+            const startedAt = Date.now();
+            while (!this.stopped && Date.now() - startedAt < ANDROID_LINK_DROP_QUIET_MS) {
+                yield delay(ANDROID_LINK_DROP_POLL_MS);
+            }
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE link drop', {
+                connectIdSuffix: uuid.slice(-8),
+                reason,
+                stopped: this.stopped,
+            });
+        });
     }
     connectWithTimeout(uuid, connect) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.stopped)
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
+            const startedAt = Date.now();
+            let succeeded = false;
             let timer;
             let timedOut = false;
             const pending = connect();
@@ -1606,6 +2018,7 @@ class ReactNativeBleTransport {
                         }, BLE_CONNECT_TIMEOUT_MS);
                     }),
                 ]);
+                succeeded = true;
                 return result;
             }
             catch (error) {
@@ -1620,11 +2033,19 @@ class ReactNativeBleTransport {
             finally {
                 if (timer)
                     clearTimeout(timer);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] connect completed', {
+                    connectIdSuffix: uuid.slice(-8),
+                    elapsedMs: Date.now() - startedAt,
+                    succeeded,
+                    backstopExpired: timedOut,
+                });
             }
         });
     }
     resolveCharacteristicsWithTimeout(uuid, device) {
         return __awaiter(this, void 0, void 0, function* () {
+            const startedAt = Date.now();
+            let succeeded = false;
             let timer;
             let timedOut = false;
             const pending = this.resolveCharacteristics(device);
@@ -1640,6 +2061,7 @@ class ReactNativeBleTransport {
                     }),
                 ]);
                 this.connectionSetupTimeoutCounts.delete(uuid);
+                succeeded = true;
                 return result;
             }
             catch (error) {
@@ -1649,11 +2071,20 @@ class ReactNativeBleTransport {
                         throw this.createWedgedBleSetupError();
                     }
                 }
+                if (reactNative.Platform.OS === 'android' && isMissingGattShapeError(error)) {
+                    this.androidGattCacheRefreshes.add(uuid);
+                }
                 throw error;
             }
             finally {
                 if (timer)
                     clearTimeout(timer);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] GATT setup completed', {
+                    connectIdSuffix: uuid.slice(-8),
+                    elapsedMs: Date.now() - startedAt,
+                    succeeded,
+                    backstopExpired: timedOut,
+                });
             }
         });
     }
@@ -1674,6 +2105,7 @@ class ReactNativeBleTransport {
         this.deviceProtocol.delete(uuid);
         this.probingProtocols.delete(uuid);
         this.staleBondErrors.delete(uuid);
+        this.iosProbeDisconnectEvidence.delete(uuid);
         this.acquiringProtocolV2.delete(uuid);
         this.protocolV2Assemblers.delete(uuid);
         this.resetProtocolV2Frames(uuid);
@@ -1745,6 +2177,7 @@ class ReactNativeBleTransport {
         this.deviceProtocol.delete(uuid);
         this.probingProtocols.delete(uuid);
         this.staleBondErrors.delete(uuid);
+        this.iosProbeDisconnectEvidence.delete(uuid);
         this.acquiringProtocolV2.delete(uuid);
         this.protocolV2Assemblers.delete(uuid);
         this.resetProtocolV2Frames(uuid);
@@ -1755,6 +2188,8 @@ class ReactNativeBleTransport {
         }
     }
     resetPlxManager() {
+        if (bleManagerResetPromise)
+            return;
         const manager = this.blePlxManager;
         this.blePlxManager = undefined;
         const reason = 'React Native BLE manager reset';
@@ -1789,19 +2224,29 @@ class ReactNativeBleTransport {
         this.deviceProtocol.clear();
         this.probingProtocols.clear();
         this.staleBondErrors.clear();
+        this.iosProbeDisconnectEvidence.clear();
         this.acquiringProtocolV2.clear();
         this.sessionProtocols.clear();
         this.protocolReprobeFailures.clear();
+        this.silentDetections.clear();
         this.writeTimeoutCounts.clear();
         this.connectionSetupTimeoutCounts.clear();
         this.monitorTokens.clear();
         this.protocolV2Assemblers.clear();
+        let reset;
         try {
-            manager === null || manager === void 0 ? void 0 : manager.destroy();
+            reset = Promise.resolve(manager === null || manager === void 0 ? void 0 : manager.destroy());
         }
         catch (error) {
-            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE manager destroy failed (ignored):', error);
+            reset = Promise.reject(error);
         }
+        bleManagerResetPromise = reset;
+        reset.then(() => {
+            if (bleManagerResetPromise === reset)
+                bleManagerResetPromise = undefined;
+        }, error => {
+            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE manager destroy failed:', error);
+        });
     }
     createProtocolMismatchError(expected) {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
@@ -1809,6 +2254,35 @@ class ReactNativeBleTransport {
     createProtocolDetectionError() {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping');
     }
+    rememberIosProbeDisconnect(uuid, phase, error) {
+        if (!isIosProbeDisconnectError(error))
+            return undefined;
+        const previous = this.iosProbeDisconnectEvidence.get(uuid);
+        const errorCode = error === null || error === void 0 ? void 0 : error.errorCode;
+        const evidence = Object.assign({ phase }, (typeof errorCode === 'string' || typeof errorCode === 'number' ? { errorCode } : {}));
+        this.iosProbeDisconnectEvidence.set(uuid, evidence);
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] probe disconnect recorded', {
+            phase,
+            errorCode: evidence.errorCode,
+            repeated: Boolean(previous),
+        });
+        if (!previous)
+            return undefined;
+        return this.consumeIosProbeDisconnect(uuid, 'repeated-probe-disconnect');
+    }
+    consumeIosProbeDisconnect(uuid, confirmation) {
+        const evidence = this.iosProbeDisconnectEvidence.get(uuid);
+        if (!evidence)
+            return undefined;
+        this.iosProbeDisconnectEvidence.delete(uuid);
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] stale bond confirmed', {
+            confirmation,
+            triggerPhase: evidence.phase,
+            triggerErrorCode: evidence.errorCode,
+            finalErrorCode: hdShared.HardwareErrorCode.BleBondInvalid,
+        });
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid);
+    }
     clearProbeProtocol(uuid, protocol) {
         if (this.probingProtocols.get(uuid) === protocol) {
             this.probingProtocols.delete(uuid);
@@ -1822,9 +2296,10 @@ class ReactNativeBleTransport {
         return (_a = this.deviceProtocol.get(uuid)) !== null && _a !== void 0 ? _a : this.probingProtocols.get(uuid);
     }
     detectProtocol(uuid, expectedProtocol, protocolHint, rebuildTransport) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (expectedProtocol === 'V1') {
+                this.iosProbeDisconnectEvidence.delete(uuid);
                 this.deviceProtocol.set(uuid, 'V1');
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol selected', {
                     deviceId: uuid,
@@ -1838,6 +2313,7 @@ class ReactNativeBleTransport {
             }
             if (expectedProtocol === 'V2') {
                 if (yield this.probeProtocolV2(uuid)) {
+                    this.iosProbeDisconnectEvidence.delete(uuid);
                     this.deviceProtocol.set(uuid, 'V2');
                     this.sessionProtocols.set(uuid, 'V2');
                     this.confirmedProtocolV2.add(uuid);
@@ -1848,6 +2324,19 @@ class ReactNativeBleTransport {
                     });
                     return 'V2';
                 }
+                const staleBondError = this.consumeIosProbeDisconnect(uuid, 'follow-up-no-response');
+                if (reactNative.Platform.OS === 'ios') {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] protocol detection ended', {
+                        outcome: 'expected-v2-no-response',
+                        expectedProtocol,
+                        protocolHint: protocolHint !== null && protocolHint !== void 0 ? protocolHint : 'none',
+                        finalErrorCode: staleBondError
+                            ? hdShared.HardwareErrorCode.BleBondInvalid
+                            : hdShared.HardwareErrorCode.RuntimeError,
+                    });
+                }
+                if (staleBondError)
+                    throw staleBondError;
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
             const sessionProtocol = this.sessionProtocols.get(uuid);
@@ -1857,6 +2346,7 @@ class ReactNativeBleTransport {
                 !protocolHint &&
                 reprobeFailures < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
             const probeOrder = trustSessionProtocol ? [sessionProtocol] : fullProbeOrder;
+            yield this.wakeSilentProtocolV1Device(uuid, probeOrder);
             for (let i = 0; i < probeOrder.length; i += 1) {
                 const protocol = probeOrder[i];
                 if (i > 0) {
@@ -1870,12 +2360,14 @@ class ReactNativeBleTransport {
                 }
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
                 if (detected) {
+                    this.iosProbeDisconnectEvidence.delete(uuid);
                     this.deviceProtocol.set(uuid, protocol);
                     this.sessionProtocols.set(uuid, protocol);
                     if (protocol === 'V2') {
                         this.confirmedProtocolV2.add(uuid);
                     }
                     this.protocolReprobeFailures.delete(uuid);
+                    this.silentDetections.delete(uuid);
                     Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
                         deviceId: uuid,
                         protocol,
@@ -1884,6 +2376,8 @@ class ReactNativeBleTransport {
                     return protocol;
                 }
             }
+            if (!this.silentDetections.has(uuid))
+                this.silentDetections.set(uuid, 'silent');
             if (trustSessionProtocol) {
                 this.protocolReprobeFailures.set(uuid, reprobeFailures + 1);
             }
@@ -1892,9 +2386,53 @@ class ReactNativeBleTransport {
             }
             this.deviceProtocol.delete(uuid);
             this.probingProtocols.delete(uuid);
+            const staleBondError = this.consumeIosProbeDisconnect(uuid, 'follow-up-no-response');
+            if (reactNative.Platform.OS === 'ios') {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] protocol detection ended', {
+                    outcome: 'all-probes-no-response',
+                    expectedProtocol: expectedProtocol !== null && expectedProtocol !== void 0 ? expectedProtocol : 'none',
+                    protocolHint: protocolHint !== null && protocolHint !== void 0 ? protocolHint : 'none',
+                    sessionProtocol: sessionProtocol !== null && sessionProtocol !== void 0 ? sessionProtocol : 'none',
+                    probeOrder: probeOrder.join(','),
+                    trustSessionProtocol,
+                    reprobeFailures,
+                    transportCached: Boolean(transportCache[uuid]),
+                    notifyActive: Boolean((_b = transportCache[uuid]) === null || _b === void 0 ? void 0 : _b.notifySubscription),
+                    staleBondRecorded: this.staleBondErrors.has(uuid),
+                    finalErrorCode: staleBondError
+                        ? hdShared.HardwareErrorCode.BleBondInvalid
+                        : hdShared.HardwareErrorCode.BleTimeoutError,
+                });
+            }
+            if (staleBondError)
+                throw staleBondError;
             throw this.createProtocolDetectionError();
         });
     }
+    wakeSilentProtocolV1Device(uuid, probeOrder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (reactNative.Platform.OS !== 'android' ||
+                probeOrder[0] !== 'V1' ||
+                this.silentDetections.get(uuid) !== 'silent') {
+                return;
+            }
+            this.silentDetections.set(uuid, 'woken');
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] sending Protocol V1 Initialize wake', {
+                connectIdSuffix: uuid.slice(-8),
+            });
+            try {
+                this.probingProtocols.set(uuid, 'V1');
+                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+            }
+            catch (error) {
+                if (shouldRethrowProtocolProbeError(error))
+                    throw error;
+            }
+            finally {
+                this.clearProbeProtocol(uuid, 'V1');
+            }
+        });
+    }
     resetProbeStateAfterProtocolProbe(uuid, protocol) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1951,7 +2489,12 @@ class ReactNativeBleTransport {
             catch (error) {
                 this.clearProbeProtocol(uuid, 'V1');
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe failed:', error);
-                if (isWedgedWriteError(error)) {
+                const shouldRethrow = shouldRethrowProtocolProbeError(error);
+                const staleBondError = this.rememberIosProbeDisconnect(uuid, 'protocol-v1-get-features', error);
+                logIosBleBondDiagnostic('protocol-v1-get-features', error, shouldRethrow ? 'rethrow' : 'fallback');
+                if (staleBondError)
+                    throw staleBondError;
+                if (shouldRethrow) {
                     throw error;
                 }
                 return false;
@@ -1967,18 +2510,28 @@ class ReactNativeBleTransport {
             this.probingProtocols.set(uuid, 'V2');
             (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             this.throwIfStaleBondError(uuid);
-            const detected = yield transport.probeProtocolV2({
-                call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
-                timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
-                logger: Log,
-                logPrefix: 'ProtocolV2 RN-BLE',
-                onProbeFailed: () => {
-                    var _a;
-                    (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
-                    this.resetProtocolV2Frames(uuid);
-                },
-                shouldRethrow: hdShared.isBleStaleBondHardwareError,
-            });
+            let detected;
+            try {
+                detected = yield transport.probeProtocolV2({
+                    call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
+                    timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+                    logger: Log,
+                    logPrefix: 'ProtocolV2 RN-BLE',
+                    onProbeFailed: () => {
+                        var _a;
+                        (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                        this.resetProtocolV2Frames(uuid);
+                    },
+                    shouldRethrow: shouldRethrowProtocolProbeError,
+                });
+            }
+            catch (error) {
+                const staleBondError = this.rememberIosProbeDisconnect(uuid, 'protocol-v2-ping', error);
+                logIosBleBondDiagnostic('protocol-v2-ping', error, 'rethrow');
+                if (staleBondError)
+                    throw staleBondError;
+                throw error;
+            }
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');
             }
@@ -2104,6 +2657,9 @@ class ReactNativeBleTransport {
                         this.rememberStaleBondError(uuid, bondError);
                         throw bondError;
                     }
+                    if (isNativeBleDisconnectError(error)) {
+                        throw toBleDisconnectHardwareError(error);
+                    }
                     if (getFirmwareUploadWriteRetryType(error) !== 'congested' ||
                         attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
                         throw error;
@@ -2146,6 +2702,7 @@ class ReactNativeBleTransport {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
+            const isProtocolProbe = this.probingProtocols.get(uuid) === 'V2';
             const callOptions = options;
             const highThroughputWrite = transport.isProtocolV2HighThroughputCall(name);
             if (highThroughputWrite) {
@@ -2186,6 +2743,14 @@ class ReactNativeBleTransport {
             }
             catch (e) {
                 Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
+                if (!isProtocolProbe &&
+                    (e === null || e === void 0 ? void 0 : e.errorCode) === hdShared.HardwareErrorCode.BleTimeoutError &&
+                    !this.monitorTokens.has(uuid)) {
+                    yield this.runLifecycleOperation(uuid, () => __awaiter(this, void 0, void 0, function* () {
+                        if (!this.monitorTokens.has(uuid))
+                            yield this.disconnectUnlocked(uuid);
+                    }));
+                }
                 throw e;
             }
             finally {
@@ -2200,7 +2765,7 @@ class ReactNativeBleTransport {
             const transport = this.getCachedTransport(uuid);
             if (!shouldRefreshNegotiatedMtu(transport.mtuSize))
                 return;
-            const refreshedDevice = yield requestNegotiatedMtu(transport.device, 'highThroughput', 1);
+            const { device: refreshedDevice } = yield requestNegotiatedMtu(transport.device, 'highThroughput', 1, transactionId => { var _a; return (_a = this.blePlxManager) === null || _a === void 0 ? void 0 : _a.cancelTransaction(transactionId); });
             transport.device = refreshedDevice;
             transport.mtuSize =
                 typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
@@ -2317,6 +2882,8 @@ class ReactNativeBleTransport {
     }
 }
 
+exports.ANDROID_LINK_DROP_QUIET_MS = ANDROID_LINK_DROP_QUIET_MS;
+exports.ANDROID_MTU_EXCHANGE_TIMEOUT_MS = ANDROID_MTU_EXCHANGE_TIMEOUT_MS;
 exports.BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD;
 exports.BLE_CONNECT_TIMEOUT_MS = BLE_CONNECT_TIMEOUT_MS;
 exports.BLE_GATT_SETUP_TIMEOUT_MS = BLE_GATT_SETUP_TIMEOUT_MS;