@onekeyfe/hd-transport-electron 1.2.2-alpha.100 → 1.2.2-alpha.102

package/dist/{noble-ble-handler-e8b87173.js → noble-ble-handler-3a1d131d.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-b37d926c.js');
+var index = require('./index-8e6acfc1.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -9,6 +9,15 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var pRetry__default = /*#__PURE__*/_interopDefaultLegacy(pRetry);
 
 const BLE_ATT_HEADER_BYTES = 3;
+function resolveNobleAttMtu(reportedMtu, platform = process.platform) {
+    if (typeof reportedMtu !== 'number' || !Number.isFinite(reportedMtu) || reportedMtu <= 0) {
+        return undefined;
+    }
+    const normalizedMtu = Math.floor(reportedMtu);
+    return platform === 'darwin' || platform === 'win32'
+        ? normalizedMtu + BLE_ATT_HEADER_BYTES
+        : normalizedMtu;
+}
 function resolveBlePacketCapacity(mtu, maximumPacketCapacity, fallbackPacketCapacity) {
     if (typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= BLE_ATT_HEADER_BYTES) {
         return fallbackPacketCapacity;
@@ -87,10 +96,54 @@ function softRefreshSubscription(params) {
 }
 
 const NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS = 5000;
-const NOBLE_BLE_CONNECTION_TIMEOUT_MS = 10000;
+const NOBLE_BLE_SUBSCRIBE_TIMEOUT_MS = 10000;
 
 let noble = null;
 let logger = null;
+let disposing = false;
+let disposePromise;
+let removeIpcHandlers;
+const pendingCancellations = new Set();
+function assertBleActive() {
+    if (disposing) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, 'Noble BLE is shutting down');
+    }
+}
+function createNobleBleConnectionError(error, messagePrefix = '') {
+    const errorMessage = error.message;
+    const isInvalidMacOsBond = (error.nativeErrorCode === 14 && error.nativeErrorDomain === 'CBErrorDomain') ||
+        (error.nativeErrorCode === 15 && error.nativeErrorDomain === 'CBATTErrorDomain');
+    if (isInvalidMacOsBond) {
+        const nativeErrorMessage = `${messagePrefix}${errorMessage}`;
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, `${hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleBondInvalid]} (${nativeErrorMessage})`, {
+            nativeErrorMessage,
+        });
+    }
+    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `${messagePrefix}${errorMessage}`);
+}
+function createNobleBleIpcErrorResponse(error) {
+    const candidate = error;
+    const errorCode = typeof (candidate === null || candidate === void 0 ? void 0 : candidate.errorCode) === 'number' ? candidate.errorCode : hdShared.HardwareErrorCode.UnknownError;
+    const message = typeof (candidate === null || candidate === void 0 ? void 0 : candidate.message) === 'string' ? candidate.message : String(error !== null && error !== void 0 ? error : 'Unknown error');
+    const name = typeof (candidate === null || candidate === void 0 ? void 0 : candidate.name) === 'string' ? candidate.name : 'Error';
+    let params;
+    if ((candidate === null || candidate === void 0 ? void 0 : candidate.params) !== undefined) {
+        try {
+            const serializedParams = JSON.stringify(candidate.params);
+            params = serializedParams === undefined ? undefined : JSON.parse(serializedParams);
+        }
+        catch (_a) {
+            params = undefined;
+        }
+    }
+    return {
+        type: 'NobleBleIpcError',
+        success: false,
+        error: Object.assign({ name,
+            message,
+            errorCode }, (params !== undefined ? { params } : {})),
+    };
+}
 const bluetoothState = {
     available: false,
     unsupported: false,
@@ -100,6 +153,57 @@ let persistentStateListener = null;
 let persistentDiscoverListener = null;
 const discoveredDevices = new Map();
 const connectedDevices = new Map();
+const connectingDevices = new Map();
+let nextConnectionGeneration = 0;
+function connectPeripheralWithCancellation(peripheral, deviceId, messagePrefix = '') {
+    assertBleActive();
+    return new Promise((resolve, reject) => {
+        var _a;
+        const generation = ++nextConnectionGeneration;
+        let settled = false;
+        const settle = (settler) => {
+            var _a;
+            if (settled)
+                return false;
+            settled = true;
+            if (((_a = connectingDevices.get(deviceId)) === null || _a === void 0 ? void 0 : _a.generation) === generation) {
+                connectingDevices.delete(deviceId);
+            }
+            settler();
+            return true;
+        };
+        const pendingConnection = {
+            peripheral,
+            generation,
+            cancel: error => {
+                settle(() => reject(error));
+            },
+        };
+        (_a = connectingDevices
+            .get(deviceId)) === null || _a === void 0 ? void 0 : _a.cancel(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, `Device ${deviceId} connect attempt was superseded`));
+        connectingDevices.set(deviceId, pendingConnection);
+        peripheral.connect(error => {
+            if (error) {
+                settle(() => reject(createNobleBleConnectionError(error, messagePrefix)));
+                return;
+            }
+            if (!settle(() => {
+                connectedDevices.set(deviceId, peripheral);
+                resolve();
+            })) {
+                const activeConnection = connectingDevices.get(deviceId);
+                if (!activeConnection || activeConnection.peripheral !== peripheral) {
+                    try {
+                        peripheral.removeAllListeners('disconnect');
+                        peripheral.disconnect(() => undefined);
+                    }
+                    catch (_a) {
+                    }
+                }
+            }
+        });
+    });
+}
 const pairedDevices = new Set();
 const deviceCharacteristics = new Map();
 const notificationCallbacks = new Map();
@@ -116,7 +220,8 @@ const DEVICE_SCAN_TIMEOUT = 5000;
 const DEVICE_CHECK_INTERVAL = 500;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
 const BLE_CLEANUP_TIMEOUT = 250;
-const BLE_IDLE_DISCONNECT_MS = 3 * 60000;
+const BLE_DISCONNECT_CONFIRM_TIMEOUT_MS = 3000;
+const BLE_IDLE_DISCONNECT_MS = 20000;
 const BLE_BUSY_BACKSTOP_MS = 10 * 60000;
 const BLE_PACKET_SIZE_FALLBACK = 192;
 const BLE_PACKET_SIZE_MAXIMUM = 244;
@@ -237,11 +342,13 @@ function updateBluetoothState(state) {
 }
 function initializeNoble() {
     return index.__awaiter(this, void 0, void 0, function* () {
+        assertBleActive();
         if (noble)
             return;
         try {
             noble = require('@stoprocent/noble');
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Noble library loaded');
+            setupPersistentStateListener();
             yield new Promise((resolve, reject) => {
                 if (!noble) {
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not initialized'));
@@ -251,11 +358,12 @@ function initializeNoble() {
                     resolve();
                     return;
                 }
-                setupPersistentStateListener();
                 const timeout = setTimeout(() => {
+                    cleanup();
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Bluetooth initialization timeout'));
                 }, BLUETOOTH_INIT_TIMEOUT);
                 const cleanup = () => {
+                    pendingCancellations.delete(cancel);
                     clearTimeout(timeout);
                     if (noble) {
                         noble.removeListener('stateChange', onStateChange);
@@ -280,8 +388,14 @@ function initializeNoble() {
                         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
                     }
                 };
+                const cancel = () => {
+                    cleanup();
+                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, 'Noble BLE is shutting down'));
+                };
+                pendingCancellations.add(cancel);
                 noble.on('stateChange', onStateChange);
             });
+            assertBleActive();
             if (!persistentDiscoverListener) {
                 persistentDiscoverListener = (peripheral) => {
                     handleDeviceDiscovered(peripheral);
@@ -328,6 +442,8 @@ function broadcastToAllWebContents(channel, payload) {
 }
 function armIdleDisconnect(deviceId, ms = BLE_IDLE_DISCONNECT_MS, reason = 'idle') {
     clearIdleDisconnect(deviceId);
+    if (disposing)
+        return;
     idleDisconnectTimers.set(deviceId, setTimeout(() => {
         var _a;
         idleDisconnectTimers.delete(deviceId);
@@ -336,7 +452,14 @@ function armIdleDisconnect(deviceId, ms = BLE_IDLE_DISCONNECT_MS, reason = 'idle
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Keep-alive timeout, disconnecting device', { deviceId, reason });
         const peripheral = connectedDevices.get(deviceId);
         const deviceName = ((_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-        const pending = disconnectDevice(deviceId)
+        const pending = unsubscribeNotifications(deviceId)
+            .catch(error => {
+            logger === null || logger === void 0 ? void 0 : logger.warn('[NobleBLE] Keep-alive unsubscribe failed, disconnecting anyway', {
+                deviceId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        })
+            .then(() => disconnectDevice(deviceId))
             .then(() => {
             broadcastToAllWebContents(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
                 id: deviceId,
@@ -356,7 +479,7 @@ function armIdleDisconnect(deviceId, ms = BLE_IDLE_DISCONNECT_MS, reason = 'idle
     }, ms));
 }
 function cleanupDevice(deviceId, webContents, options = {}) {
-    var _a;
+    var _a, _b;
     const { cleanupConnection = true, cleanupDiscoveredCache = false, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', disconnectReason = hdShared.EBleDisconnectReason.DeviceDisconnected, } = options;
     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device cleanup', {
         deviceId,
@@ -370,6 +493,8 @@ function cleanupDevice(deviceId, webContents, options = {}) {
     const peripheral = connectedDevices.get(deviceId);
     const deviceName = ((_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
     if (cleanupConnection) {
+        (_b = connectingDevices
+            .get(deviceId)) === null || _b === void 0 ? void 0 : _b.cancel(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, `Device ${deviceId} disconnected while connecting`));
         const disconnectEntry = deviceDisconnectListeners.get(deviceId);
         if (disconnectEntry) {
             disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
@@ -409,6 +534,7 @@ function handleDeviceDisconnect(deviceId, webContents) {
     });
     cleanupDevice(deviceId, webContents, {
         cleanupConnection: true,
+        cleanupDiscoveredCache: true,
         sendDisconnectEvent: true,
         cancelOperations: true,
         reason: 'auto-disconnect',
@@ -432,13 +558,14 @@ function setupMtuListener(peripheral, deviceId, webContents) {
         existing.peripheral.removeListener('mtu', existing.listener);
     }
     const listener = (mtu) => {
-        if (!Number.isFinite(mtu) || mtu <= 0)
+        const normalizedMtu = resolveNobleAttMtu(mtu);
+        if (normalizedMtu === undefined)
             return;
         if (webContents.isDestroyed())
             return;
         webContents.send(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_MTU_CHANGED, {
             id: deviceId,
-            mtu,
+            mtu: normalizedMtu,
         });
     };
     deviceMtuListeners.set(deviceId, { peripheral, listener });
@@ -446,6 +573,7 @@ function setupMtuListener(peripheral, deviceId, webContents) {
 }
 function writeCharacteristicWithoutResponse(deviceId, writeCharacteristic, buffer) {
     return index.__awaiter(this, void 0, void 0, function* () {
+        assertBleActive();
         return new Promise((resolve, reject) => {
             writeCharacteristic.write(buffer, true, (error) => {
                 if (error) {
@@ -545,7 +673,7 @@ function transmitHexDataToDevice(deviceId, hexData, options) {
         armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
         const toBuffer = Buffer.from(hexData, 'hex');
         const doGetWriteCharacteristic = () => { var _a; return (_a = deviceCharacteristics.get(deviceId)) === null || _a === void 0 ? void 0 : _a.write; };
-        const packetCapacity = resolveBlePacketCapacity(peripheral.mtu, BLE_PACKET_SIZE_MAXIMUM, BLE_PACKET_SIZE_FALLBACK);
+        const packetCapacity = resolveBlePacketCapacity(resolveNobleAttMtu(peripheral.mtu), BLE_PACKET_SIZE_MAXIMUM, BLE_PACKET_SIZE_FALLBACK);
         const pacingDelayMs = resolveNobleBleWritePacingDelay(options);
         if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
             const writeCharacteristic = doGetWriteCharacteristic();
@@ -590,18 +718,37 @@ function transmitHexDataToDevice(deviceId, hexData, options) {
         }
     });
 }
+const BLE_COLD_CONNECT_SCAN_TIMEOUT_MS = 1500;
+const SERVICE_DISCOVERY_MAX_ATTEMPTS = 2;
+const bleNamesById = new Map();
+function rememberBleName(deviceId, name) {
+    const trimmed = name === null || name === void 0 ? void 0 : name.trim();
+    if (trimmed) {
+        bleNamesById.set(deviceId, trimmed);
+    }
+}
+function resolveBleName(deviceId) {
+    var _a, _b, _c, _d, _e, _f;
+    const live = ((_c = (_b = (_a = connectedDevices.get(deviceId)) === null || _a === void 0 ? void 0 : _a.advertisement) === null || _b === void 0 ? void 0 : _b.localName) === null || _c === void 0 ? void 0 : _c.trim()) ||
+        ((_f = (_e = (_d = discoveredDevices.get(deviceId)) === null || _d === void 0 ? void 0 : _d.advertisement) === null || _e === void 0 ? void 0 : _e.localName) === null || _f === void 0 ? void 0 : _f.trim());
+    return live || bleNamesById.get(deviceId);
+}
+function shouldConnectByIdFirst(deviceId) {
+    return hdShared.isPro2FamilyBleName(resolveBleName(deviceId));
+}
 function handleDeviceDiscovered(peripheral) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!isOneKeyPeripheral(peripheral)) {
         return;
     }
     const isNewDevice = !discoveredDevices.has(peripheral.id);
     discoveredDevices.set(peripheral.id, peripheral);
+    rememberBleName(peripheral.id, (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName);
     if (isNewDevice) {
         logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] OneKey BLE device discovered', {
             deviceId: peripheral.id,
-            name: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device',
-            serviceUUIDs: ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.serviceUuids) || [],
+            name: ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName) || 'Unknown Device',
+            serviceUUIDs: ((_c = peripheral.advertisement) === null || _c === void 0 ? void 0 : _c.serviceUuids) || [],
         });
     }
 }
@@ -627,8 +774,9 @@ function waitForNobleScanStop(nobleInstance) {
         });
     });
 }
-function performTargetedScan(targetDeviceId) {
+function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS) {
     return index.__awaiter(this, void 0, void 0, function* () {
+        assertBleActive();
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
         }
@@ -640,6 +788,7 @@ function performTargetedScan(targetDeviceId) {
                 if (settled)
                     return;
                 settled = true;
+                pendingCancellations.delete(cancel);
                 if (timeoutId)
                     clearTimeout(timeoutId);
                 nobleInstance.removeListener('discover', onDiscover);
@@ -649,6 +798,7 @@ function performTargetedScan(targetDeviceId) {
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, error.message));
                     return;
                 }
+                assertBleActive();
                 if (peripheral) {
                     discoveredDevices.set(peripheral.id, peripheral);
                 }
@@ -667,7 +817,11 @@ function performTargetedScan(targetDeviceId) {
             const timeoutId = setTimeout(() => {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
                 finish(null).catch(reject);
-            }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
+            }, timeoutMs);
+            const cancel = () => {
+                finish(null, new Error('Noble BLE is shutting down')).catch(reject);
+            };
+            pendingCancellations.add(cancel);
             nobleInstance.on('discover', onDiscover);
             nobleInstance.startScanning([], true, (error) => {
                 if (error) {
@@ -687,14 +841,18 @@ function enumerateDevices() {
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
         }
+        assertBleActive();
         const nobleInstance = noble;
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device enumeration');
         discoveredDevices.clear();
         ensureDiscoverListener();
         return new Promise((resolve, reject) => {
             const devices = [];
+            let settled = false;
             let intervalId;
             const cleanup = () => index.__awaiter(this, void 0, void 0, function* () {
+                settled = true;
+                pendingCancellations.delete(cancel);
                 clearTimeout(timeoutId);
                 if (intervalId)
                     clearInterval(intervalId);
@@ -716,13 +874,21 @@ function enumerateDevices() {
                 connectedDevices.forEach(pushDevice);
             };
             const timeoutId = setTimeout(() => index.__awaiter(this, void 0, void 0, function* () {
+                if (settled)
+                    return;
                 checkDevices();
                 yield cleanup();
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scan completed, found devices:', devices.length);
                 resolve(devices);
             }), DEVICE_SCAN_TIMEOUT);
+            const cancel = () => {
+                cleanup().then(() => resolve([]), reject);
+            };
+            pendingCancellations.add(cancel);
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning for OneKey BLE devices');
             nobleInstance.startScanning([], true, (error) => index.__awaiter(this, void 0, void 0, function* () {
+                if (settled)
+                    return;
                 if (error) {
                     yield cleanup();
                     logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start scanning:', error);
@@ -763,12 +929,14 @@ function getDevice(deviceId) {
     const peripheral = discoveredDevices.get(deviceId);
     if (peripheral) {
         const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-        return Object.assign({ commType: 'electron-ble', id: peripheral.id, name: deviceName, state: peripheral.state || 'disconnected' }, (typeof peripheral.mtu === 'number' ? { mtu: peripheral.mtu } : {}));
+        const mtu = resolveNobleAttMtu(peripheral.mtu);
+        return Object.assign({ commType: 'electron-ble', id: peripheral.id, name: deviceName, state: peripheral.state || 'disconnected' }, (mtu === undefined ? {} : { mtu }));
     }
     const connectedPeripheral = connectedDevices.get(deviceId);
     if (connectedPeripheral) {
         const deviceName = ((_b = connectedPeripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName) || 'Unknown Device';
-        return Object.assign({ commType: 'electron-ble', id: connectedPeripheral.id, name: deviceName, state: connectedPeripheral.state || 'connected' }, (typeof connectedPeripheral.mtu === 'number' ? { mtu: connectedPeripheral.mtu } : {}));
+        const mtu = resolveNobleAttMtu(connectedPeripheral.mtu);
+        return Object.assign({ commType: 'electron-ble', id: connectedPeripheral.id, name: deviceName, state: connectedPeripheral.state || 'connected' }, (mtu === undefined ? {} : { mtu }));
     }
     return {
         commType: 'electron-ble',
@@ -779,13 +947,16 @@ function getDevice(deviceId) {
 }
 function discoverServicesAndCharacteristics(peripheral) {
     return index.__awaiter(this, void 0, void 0, function* () {
+        assertBleActive();
         let timeoutId;
         let onDisconnect;
         const cleanup = () => {
             if (timeoutId)
                 clearTimeout(timeoutId);
-            if (onDisconnect)
+            if (onDisconnect) {
                 peripheral.removeListener('disconnect', onDisconnect);
+                pendingCancellations.delete(onDisconnect);
+            }
         };
         const timeoutPromise = new Promise((_, reject) => {
             timeoutId = setTimeout(() => {
@@ -798,11 +969,12 @@ function discoverServicesAndCharacteristics(peripheral) {
                 logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Device disconnected during service discovery');
                 reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'Device disconnected during service discovery'));
             };
+            pendingCancellations.add(onDisconnect);
             peripheral.once('disconnect', onDisconnect);
         });
         const discoveryPromise = (() => index.__awaiter(this, void 0, void 0, function* () {
             const services = yield new Promise((resolve, reject) => {
-                peripheral.discoverServices([], (error, svc) => {
+                peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
                     if (error) {
                         logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed:', error);
                         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, error.message));
@@ -812,8 +984,9 @@ function discoverServicesAndCharacteristics(peripheral) {
                     }
                 });
             });
+            assertBleActive();
             if (!services || services.length === 0) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No services found');
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
             }
             logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] services discovered', {
                 deviceId: peripheral.id,
@@ -884,12 +1057,8 @@ function forceReconnectPeripheral(peripheral, deviceId) {
                 callback();
             }), { timeoutMs: BLE_CLEANUP_TIMEOUT, timeoutBehavior: 'resolve' });
         }
-        yield runBleCallbackOperation(callback => peripheral.connect(callback), {
-            timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
-            timeoutBehavior: 'reject',
-        });
+        yield connectPeripheralWithCancellation(peripheral, deviceId);
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force reconnect successful');
-        connectedDevices.set(deviceId, peripheral);
         yield hdShared.wait(500);
     });
 }
@@ -906,17 +1075,7 @@ function freshScanAndDiscover(deviceId, webContents) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found in fresh scan`);
         }
         discoveredDevices.set(deviceId, freshPeripheral);
-        yield new Promise((resolve, reject) => {
-            freshPeripheral.connect((error) => {
-                if (error) {
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Fresh peripheral connection failed: ${error.message}`));
-                }
-                else {
-                    connectedDevices.set(deviceId, freshPeripheral);
-                    resolve();
-                }
-            });
-        });
+        yield connectPeripheralWithCancellation(freshPeripheral, deviceId, 'Fresh peripheral connection failed: ');
         setupDisconnectListener(freshPeripheral, deviceId, webContents);
         yield hdShared.wait(500);
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting service discovery with fresh peripheral');
@@ -930,11 +1089,11 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
                 deviceId,
                 peripheralState: peripheral.state,
                 attempt: attemptNumber,
-                maxRetries: 5,
+                maxRetries: SERVICE_DISCOVERY_MAX_ATTEMPTS,
                 targetUUIDs: ONEKEY_SERVICE_UUIDS,
             });
             if (attemptNumber > 1) {
-                logger === null || logger === void 0 ? void 0 : logger.info(`[NobleBLE] Service discovery retry attempt ${attemptNumber}/5`);
+                logger === null || logger === void 0 ? void 0 : logger.info(`[NobleBLE] Service discovery retry attempt ${attemptNumber}/${SERVICE_DISCOVERY_MAX_ATTEMPTS}`);
             }
             if (peripheral.state !== 'connected') {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Device not connected: ${peripheral.state}`);
@@ -943,18 +1102,19 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
                 return yield discoverServicesAndCharacteristics(peripheral);
             }
             catch (error) {
-                logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] No services found (attempt ${attemptNumber}/5)`);
-                if (attemptNumber < 5) {
-                    logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Will retry service discovery (attempt ${attemptNumber + 1}/5)`);
+                logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] No services found (attempt ${attemptNumber}/${SERVICE_DISCOVERY_MAX_ATTEMPTS})`);
+                if (attemptNumber < SERVICE_DISCOVERY_MAX_ATTEMPTS) {
+                    logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Will retry service discovery (attempt ${attemptNumber + 1}/${SERVICE_DISCOVERY_MAX_ATTEMPTS})`);
                 }
                 throw error;
             }
         }), {
-            retries: 4,
+            retries: SERVICE_DISCOVERY_MAX_ATTEMPTS - 1,
             factor: 1.5,
-            minTimeout: 1000,
+            minTimeout: 500,
             maxTimeout: 3000,
             onFailedAttempt: error => {
+                assertBleActive();
                 logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Service discovery attempt ${error.attemptNumber} failed:`, {
                     message: error.message,
                     retriesLeft: error.retriesLeft,
@@ -966,23 +1126,29 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
 }
 function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        setupDisconnectListener(peripheral, deviceId, webContents);
         try {
-            return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+            yield forceReconnectPeripheral(peripheral, deviceId);
         }
-        catch (initialError) {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct service discovery failed, retrying after reconnect', {
-                deviceId,
-                error: initialError,
-            });
+        catch (resetError) {
+            if (hdShared.isBleStaleBondHardwareError(resetError) ||
+                (resetError === null || resetError === void 0 ? void 0 : resetError.errorCode) === hdShared.HardwareErrorCode.BleDeviceDisconnected) {
+                throw resetError;
+            }
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection reset before discovery failed, continuing', resetError);
         }
-        yield forceReconnectPeripheral(peripheral, deviceId);
+        assertBleActive();
         setupDisconnectListener(peripheral, deviceId, webContents);
         try {
             return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
         }
-        catch (reconnectError) {
-            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed after reconnect, attempting fresh scan...', reconnectError);
+        catch (discoveryError) {
+            if (peripheral.state === 'connected') {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed on a live link, dropping it before the fresh scan', discoveryError);
+                yield disconnectDevice(deviceId).catch(() => undefined);
+            }
+            else {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed, attempting fresh scan...', discoveryError);
+            }
             return freshScanAndDiscover(deviceId, webContents);
         }
     });
@@ -993,21 +1159,26 @@ const directConnectCooldownUntil = new Map();
 function tryDirectConnectById(deviceId) {
     var _a;
     return index.__awaiter(this, void 0, void 0, function* () {
+        assertBleActive();
         const nobleInstance = noble;
         if (!(nobleInstance === null || nobleInstance === void 0 ? void 0 : nobleInstance.connectAsync))
             return undefined;
         const cooldownUntil = (_a = directConnectCooldownUntil.get(deviceId)) !== null && _a !== void 0 ? _a : 0;
         if (Date.now() < cooldownUntil)
             return undefined;
+        let timer;
+        let cancel;
         try {
             const directPromise = nobleInstance.connectAsync(deviceId);
             const raced = yield Promise.race([
                 directPromise,
                 new Promise(resolve => {
-                    setTimeout(() => resolve('timeout'), DIRECT_CONNECT_TIMEOUT_MS);
+                    cancel = () => resolve('timeout');
+                    pendingCancellations.add(cancel);
+                    timer = setTimeout(cancel, DIRECT_CONNECT_TIMEOUT_MS);
                 }),
             ]);
-            if (raced === 'timeout') {
+            if (raced === 'timeout' || disposing) {
                 directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id timed out, falling back to scan', {
                     deviceId,
@@ -1039,10 +1210,15 @@ function tryDirectConnectById(deviceId) {
             });
             return undefined;
         }
+        finally {
+            clearTimeout(timer);
+            if (cancel)
+                pendingCancellations.delete(cancel);
+        }
     });
 }
 function connectDevice(deviceId, webContents) {
-    var _a;
+    var _a, _b, _c;
     return index.__awaiter(this, void 0, void 0, function* () {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
             deviceId,
@@ -1054,40 +1230,55 @@ function connectDevice(deviceId, webContents) {
         });
         let peripheral = (_a = discoveredDevices.get(deviceId)) !== null && _a !== void 0 ? _a : connectedDevices.get(deviceId);
         if (!peripheral) {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device not discovered, attempting targeted scan for:', deviceId);
             if (!noble) {
                 yield initializeNoble();
             }
             if (!noble) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
             }
-            peripheral = yield tryDirectConnectById(deviceId);
-            if (peripheral) {
-                discoveredDevices.set(deviceId, peripheral);
-            }
-        }
-        if (!peripheral) {
-            try {
-                const foundPeripheral = yield performTargetedScan(deviceId);
-                if (!foundPeripheral) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found even after targeted scan`);
+            const byIdFirst = shouldConnectByIdFirst(deviceId);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Resolving device for cold connect', {
+                deviceId,
+                name: (_b = resolveBleName(deviceId)) !== null && _b !== void 0 ? _b : 'unknown',
+                strategy: byIdFirst ? 'connect-by-id-first' : 'scan-first',
+            });
+            const scanForPeripheral = () => index.__awaiter(this, void 0, void 0, function* () {
+                var _d;
+                try {
+                    return (_d = (yield performTargetedScan(deviceId, BLE_COLD_CONNECT_SCAN_TIMEOUT_MS))) !== null && _d !== void 0 ? _d : undefined;
                 }
-                peripheral = foundPeripheral;
-            }
-            catch (error) {
-                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Targeted scan failed:', error);
-                throw error;
+                catch (scanError) {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan failed', {
+                        deviceId,
+                        error: scanError instanceof Error ? scanError.message : String(scanError),
+                    });
+                    return undefined;
+                }
+            });
+            const connectById = () => index.__awaiter(this, void 0, void 0, function* () {
+                const found = yield tryDirectConnectById(deviceId);
+                if (found) {
+                    discoveredDevices.set(deviceId, found);
+                }
+                return found;
+            });
+            peripheral = byIdFirst ? yield connectById() : yield scanForPeripheral();
+            if (!peripheral) {
+                peripheral = byIdFirst ? yield scanForPeripheral() : yield connectById();
             }
         }
+        assertBleActive();
         if (!peripheral) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found`);
         }
+        rememberBleName(deviceId, (_c = peripheral.advertisement) === null || _c === void 0 ? void 0 : _c.localName);
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connecting to device:', deviceId);
         if (peripheral.state === 'connected') {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already connected, skipping connection step');
             if (!connectedDevices.has(deviceId)) {
                 connectedDevices.set(deviceId, peripheral);
             }
+            assertBleActive();
             setupDisconnectListener(peripheral, deviceId, webContents);
             if (deviceCharacteristics.has(deviceId)) {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device characteristics already available');
@@ -1112,6 +1303,7 @@ function connectDevice(deviceId, webContents) {
             }
             try {
                 const characteristics = yield setupConnectionAndDiscoverServices(peripheral, deviceId, webContents);
+                assertBleActive();
                 deviceCharacteristics.set(deviceId, characteristics);
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
             }
@@ -1122,65 +1314,46 @@ function connectDevice(deviceId, webContents) {
             }
             return;
         }
-        return new Promise((resolve, reject) => {
-            let connectionTimedOut = false;
-            const timeout = setTimeout(() => {
-                connectionTimedOut = true;
-                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'Connection timeout'));
-            }, NOBLE_BLE_CONNECTION_TIMEOUT_MS);
-            const connectedPeripheral = peripheral;
-            connectedPeripheral.connect((error) => index.__awaiter(this, void 0, void 0, function* () {
-                clearTimeout(timeout);
-                if (connectionTimedOut) {
-                    if (!error) {
-                        try {
-                            connectedPeripheral.disconnect(() => undefined);
-                        }
-                        catch (_a) {
-                        }
-                    }
-                    return;
-                }
-                if (error) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection failed:', error);
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, error.message));
-                    return;
-                }
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connected to device:', deviceId);
-                connectedDevices.set(deviceId, connectedPeripheral);
-                try {
-                    const characteristics = yield setupConnectionAndDiscoverServices(connectedPeripheral, deviceId, webContents);
-                    deviceCharacteristics.set(deviceId, characteristics);
-                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
-                    resolve();
-                }
-                catch (setupError) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection setup failed:', setupError);
-                    connectedPeripheral.disconnect(() => {
-                        reject(setupError);
-                    });
-                }
-            }));
-        });
+        const connectedPeripheral = peripheral;
+        yield connectPeripheralWithCancellation(connectedPeripheral, deviceId);
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connected to device:', deviceId);
+        try {
+            const characteristics = yield setupConnectionAndDiscoverServices(connectedPeripheral, deviceId, webContents);
+            assertBleActive();
+            deviceCharacteristics.set(deviceId, characteristics);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
+        }
+        catch (setupError) {
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection setup failed:', setupError);
+            yield disconnectDevice(deviceId).catch(() => undefined);
+            throw setupError;
+        }
     });
 }
 function disconnectDevice(deviceId) {
+    var _a;
     return index.__awaiter(this, void 0, void 0, function* () {
-        const peripheral = connectedDevices.get(deviceId);
+        const pendingConnection = connectingDevices.get(deviceId);
+        const peripheral = (_a = connectedDevices.get(deviceId)) !== null && _a !== void 0 ? _a : pendingConnection === null || pendingConnection === void 0 ? void 0 : pendingConnection.peripheral;
         if (!peripheral) {
             return;
         }
+        pendingConnection === null || pendingConnection === void 0 ? void 0 : pendingConnection.cancel(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, `Device ${deviceId} connection cancelled`));
         const disconnectEntry = deviceDisconnectListeners.get(deviceId);
         if (disconnectEntry) {
             disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
             deviceDisconnectListeners.delete(deviceId);
         }
         yield runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
-            timeoutMs: BLE_CLEANUP_TIMEOUT,
+            timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
             timeoutBehavior: 'resolve',
         });
+        if (peripheral.state === 'connected') {
+            logger === null || logger === void 0 ? void 0 : logger.warn('[NobleBLE] Physical disconnect did not confirm in time', { deviceId });
+        }
         cleanupDevice(deviceId, undefined, {
             cleanupConnection: true,
+            cleanupDiscoveredCache: true,
             sendDisconnectEvent: false,
             cancelOperations: true,
             reason: 'manual-disconnect',
@@ -1208,7 +1381,8 @@ function unsubscribeNotifications(deviceId) {
             subscribedDevices.delete(deviceId);
         }
         finally {
-            subscriptionOperations.set(deviceId, 'idle');
+            if (!disposing)
+                subscriptionOperations.set(deviceId, 'idle');
         }
     });
 }
@@ -1258,10 +1432,12 @@ function subscribeNotifications(deviceId, callback) {
                     timeoutMs: BLE_CLEANUP_TIMEOUT,
                     timeoutBehavior: 'resolve',
                 });
+                assertBleActive();
                 yield runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
-                    timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+                    timeoutMs: NOBLE_BLE_SUBSCRIBE_TIMEOUT_MS,
                     timeoutBehavior: 'reject',
                 });
+                assertBleActive();
                 notifyCharacteristic.on('data', (data) => {
                     if (!pairedDevices.has(deviceId)) {
                         pairedDevices.add(deviceId);
@@ -1271,22 +1447,45 @@ function subscribeNotifications(deviceId, callback) {
                 });
             });
         }
+        const subscribeStartedAt = Date.now();
         try {
             yield rebuildAppSubscription(deviceId, notifyCharacteristic);
+            assertBleActive();
             subscribedDevices.set(deviceId, true);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification subscription active', {
+                deviceId,
+                ms: Date.now() - subscribeStartedAt,
+            });
+        }
+        catch (error) {
+            throw createNobleBleConnectionError(error, 'Notification subscription failed: ');
         }
         finally {
-            subscriptionOperations.set(deviceId, 'idle');
+            if (!disposing)
+                subscriptionOperations.set(deviceId, 'idle');
         }
     });
 }
 function setupNobleBleHandlers(webContents) {
+    if (disposing)
+        return;
     try {
         logger = require('electron-log');
         const { ipcMain } = require('electron');
+        const channels = new Set();
+        removeIpcHandlers = () => channels.forEach(channel => ipcMain.removeHandler(channel));
         const handle = (channel, listener) => {
+            channels.add(channel);
             ipcMain.removeHandler(channel);
-            ipcMain.handle(channel, listener);
+            ipcMain.handle(channel, (...args) => index.__awaiter(this, void 0, void 0, function* () {
+                try {
+                    assertBleActive();
+                    return yield Promise.resolve(listener(...args));
+                }
+                catch (error) {
+                    return createNobleBleIpcErrorResponse(error);
+                }
+            }));
         };
         safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
         handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
@@ -1383,6 +1582,8 @@ function setupNobleBleHandlers(webContents) {
             }
         }));
         webContents.on('destroyed', () => {
+            if (disposing)
+                return;
             safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
             (() => index.__awaiter(this, void 0, void 0, function* () {
                 const deviceIds = Array.from(connectedDevices.keys());
@@ -1391,10 +1592,6 @@ function setupNobleBleHandlers(webContents) {
                     yield disconnectDevice(deviceId).catch(() => undefined);
                 }
                 yield stopScanning().catch(() => undefined);
-                if (noble && persistentStateListener) {
-                    noble.removeListener('stateChange', persistentStateListener);
-                    persistentStateListener = null;
-                }
                 cleanupNobleListeners();
                 discoveredDevices.clear();
                 safeLog(logger, 'info', 'Noble BLE cleanup completed');
@@ -1409,6 +1606,65 @@ function setupNobleBleHandlers(webContents) {
         throw error;
     }
 }
+function disposeNobleBleSupport(releaseNoble = instance => instance.stop()) {
+    if (disposePromise)
+        return disposePromise;
+    disposing = true;
+    removeIpcHandlers === null || removeIpcHandlers === void 0 ? void 0 : removeIpcHandlers();
+    const instance = noble;
+    const deviceIds = new Set([...connectedDevices.keys(), ...connectingDevices.keys()]);
+    const pendingPeripherals = Array.from(connectingDevices.values(), pending => pending.peripheral);
+    for (const cancel of pendingCancellations)
+        cancel();
+    for (const id of idleDisconnectTimers.keys())
+        clearIdleDisconnect(id);
+    for (const pending of connectingDevices.values()) {
+        pending.cancel(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, 'Noble BLE is shutting down'));
+    }
+    let timeout;
+    disposePromise = (() => index.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield Promise.race([
+                Promise.allSettled([
+                    stopScanning(),
+                    ...pendingPeripherals.map(peripheral => runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+                        timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+                        timeoutBehavior: 'resolve',
+                    })),
+                    ...Array.from(deviceIds, (id) => index.__awaiter(this, void 0, void 0, function* () {
+                        yield unsubscribeNotifications(id).catch(() => undefined);
+                        yield disconnectDevice(id).catch(() => undefined);
+                    })),
+                ]),
+                new Promise(resolve => {
+                    timeout = setTimeout(() => {
+                        logger === null || logger === void 0 ? void 0 : logger.warn('[NobleBLE] Process dispose timed out; releasing native manager');
+                        resolve();
+                    }, 3500);
+                }),
+            ]);
+        }
+        finally {
+            clearTimeout(timeout);
+            cleanupNobleListeners();
+            if (instance && persistentStateListener) {
+                instance.removeListener('stateChange', persistentStateListener);
+                persistentStateListener = null;
+            }
+            for (const id of deviceIds)
+                cleanupDevice(id);
+            discoveredDevices.clear();
+            directConnectCooldownUntil.clear();
+            if (instance)
+                releaseNoble(instance);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Process dispose completed');
+        }
+    }))();
+    return disposePromise;
+}
 
+exports.createNobleBleConnectionError = createNobleBleConnectionError;
+exports.createNobleBleIpcErrorResponse = createNobleBleIpcErrorResponse;
+exports.disposeNobleBleSupport = disposeNobleBleSupport;
 exports.resolveNobleBleWritePacingDelay = resolveNobleBleWritePacingDelay;
 exports.setupNobleBleHandlers = setupNobleBleHandlers;