@onekeyfe/hd-transport-electron 1.2.2-alpha.8 → 1.2.2

package/dist/{noble-ble-handler-95c5cf0d.js → noble-ble-handler-23c86603.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-00297050.js');
+var index = require('./index-474dbbae.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -96,10 +96,66 @@ 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 nativeReleased = false;
+let disposePromise;
+let windowCleanup;
+let removeIpcHandlers;
+const pendingCancellations = new Set();
+const pendingEnumerations = new Set();
+const nativeConnections = new Set();
+function trackNativeConnection(operation, cancel) {
+    const connection = {
+        cancel,
+        settled: operation.then(() => undefined, () => undefined),
+    };
+    nativeConnections.add(connection);
+    connection.settled = connection.settled.finally(() => nativeConnections.delete(connection));
+}
+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,
@@ -109,6 +165,86 @@ 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);
+        let completeNative;
+        trackNativeConnection(new Promise(resolve => {
+            completeNative = resolve;
+        }), () => {
+            var _a;
+            if (typeof peripheral.cancelConnect === 'function')
+                peripheral.cancelConnect();
+            else
+                (_a = noble === null || noble === void 0 ? void 0 : noble.cancelConnect) === null || _a === void 0 ? void 0 : _a.call(noble, deviceId);
+        });
+        const onConnect = (error) => {
+            if (nativeReleased) {
+                completeNative();
+                return;
+            }
+            if (error) {
+                settle(() => reject(createNobleBleConnectionError(error, messagePrefix)));
+                completeNative();
+                return;
+            }
+            if (!settle(() => {
+                connectedDevices.set(deviceId, peripheral);
+                resolve();
+            })) {
+                const activeConnection = connectingDevices.get(deviceId);
+                if (!activeConnection || activeConnection.peripheral !== peripheral) {
+                    try {
+                        peripheral.removeAllListeners('disconnect');
+                        runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+                            timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+                            timeoutBehavior: 'resolve',
+                        })
+                            .catch(() => undefined)
+                            .finally(completeNative);
+                        return;
+                    }
+                    catch (_a) {
+                    }
+                }
+            }
+            completeNative();
+        };
+        try {
+            peripheral.connect(onConnect);
+        }
+        catch (error) {
+            completeNative();
+            settle(() => reject(error));
+        }
+    });
+}
 const pairedDevices = new Set();
 const deviceCharacteristics = new Map();
 const notificationCallbacks = new Map();
@@ -247,6 +383,7 @@ function updateBluetoothState(state) {
 }
 function initializeNoble() {
     return index.__awaiter(this, void 0, void 0, function* () {
+        assertBleActive();
         if (noble)
             return;
         try {
@@ -263,9 +400,11 @@ function initializeNoble() {
                     return;
                 }
                 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);
@@ -290,8 +429,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);
@@ -338,6 +483,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);
@@ -373,7 +520,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,
@@ -387,6 +534,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);
@@ -465,6 +614,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) {
@@ -667,6 +817,7 @@ function waitForNobleScanStop(nobleInstance) {
 }
 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');
         }
@@ -678,6 +829,7 @@ function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN
                 if (settled)
                     return;
                 settled = true;
+                pendingCancellations.delete(cancel);
                 if (timeoutId)
                     clearTimeout(timeoutId);
                 nobleInstance.removeListener('discover', onDiscover);
@@ -687,6 +839,7 @@ function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, error.message));
                     return;
                 }
+                assertBleActive();
                 if (peripheral) {
                     discoveredDevices.set(peripheral.id, peripheral);
                 }
@@ -706,6 +859,10 @@ function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
                 finish(null).catch(reject);
             }, 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) {
@@ -717,7 +874,7 @@ function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN
         });
     });
 }
-function enumerateDevices() {
+function enumerateDevices(isWindowDestroyed) {
     return index.__awaiter(this, void 0, void 0, function* () {
         if (!noble) {
             yield initializeNoble();
@@ -725,19 +882,30 @@ function enumerateDevices() {
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
         }
+        assertBleActive();
+        if (isWindowDestroyed())
+            return [];
         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* () {
-                clearTimeout(timeoutId);
-                if (intervalId)
-                    clearInterval(intervalId);
-                yield waitForNobleScanStop(nobleInstance);
-            });
+            let cleanupPromise;
+            const cleanup = () => {
+                if (!cleanupPromise) {
+                    settled = true;
+                    pendingCancellations.delete(cancel);
+                    clearTimeout(timeoutId);
+                    if (intervalId)
+                        clearInterval(intervalId);
+                    cleanupPromise = waitForNobleScanStop(nobleInstance).finally(() => {
+                        pendingEnumerations.delete(cancel);
+                    });
+                }
+                return cleanupPromise;
+            };
             const pushDevice = (peripheral, id) => {
                 var _a;
                 if (devices.some(d => d.id === id))
@@ -754,13 +922,20 @@ 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);
+            pendingEnumerations.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);
@@ -775,7 +950,7 @@ function enumerateDevices() {
 }
 function stopScanning() {
     return index.__awaiter(this, void 0, void 0, function* () {
-        if (!noble)
+        if (!noble || nativeReleased)
             return;
         const nobleInstance = noble;
         yield waitForNobleScanStop(nobleInstance);
@@ -819,13 +994,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(() => {
@@ -838,6 +1016,7 @@ 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* () {
@@ -852,6 +1031,7 @@ function discoverServicesAndCharacteristics(peripheral) {
                     }
                 });
             });
+            assertBleActive();
             if (!services || services.length === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
             }
@@ -924,12 +1104,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);
     });
 }
@@ -946,17 +1122,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');
@@ -995,6 +1161,7 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
             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,
@@ -1010,8 +1177,13 @@ function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
             yield forceReconnectPeripheral(peripheral, deviceId);
         }
         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);
         }
+        assertBleActive();
         setupDisconnectListener(peripheral, deviceId, webContents);
         try {
             return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
@@ -1034,36 +1206,46 @@ 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;
+        let abandoned = false;
         try {
             const directPromise = nobleInstance.connectAsync(deviceId);
+            trackNativeConnection(directPromise.then((late) => index.__awaiter(this, void 0, void 0, function* () {
+                if ((!abandoned && !disposing) || nativeReleased)
+                    return;
+                const peripheral = late !== null && late !== void 0 ? late : discoveredDevices.get(deviceId);
+                if ((peripheral === null || peripheral === void 0 ? void 0 : peripheral.state) === 'connected' && !connectedDevices.has(deviceId)) {
+                    peripheral.removeAllListeners('disconnect');
+                    yield runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+                        timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+                        timeoutBehavior: 'resolve',
+                    });
+                }
+            })), () => { var _a; return (_a = nobleInstance.cancelConnect) === null || _a === void 0 ? void 0 : _a.call(nobleInstance, deviceId); });
             const raced = yield Promise.race([
                 directPromise,
                 new Promise(resolve => {
-                    setTimeout(() => resolve('timeout'), DIRECT_CONNECT_TIMEOUT_MS);
+                    cancel = () => {
+                        abandoned = true;
+                        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,
                 });
-                directPromise
-                    .then(late => {
-                    const latePeripheral = late !== null && late !== void 0 ? late : discoveredDevices.get(deviceId);
-                    if (latePeripheral &&
-                        latePeripheral.state === 'connected' &&
-                        !connectedDevices.has(deviceId)) {
-                        latePeripheral.removeAllListeners('disconnect');
-                        latePeripheral.disconnect(() => undefined);
-                    }
-                })
-                    .catch(() => undefined);
                 return undefined;
             }
             const peripheral = raced !== null && raced !== void 0 ? raced : discoveredDevices.get(deviceId);
@@ -1080,6 +1262,11 @@ function tryDirectConnectById(deviceId) {
             });
             return undefined;
         }
+        finally {
+            clearTimeout(timer);
+            if (cancel)
+                pendingCancellations.delete(cancel);
+        }
     });
 }
 function connectDevice(deviceId, webContents) {
@@ -1093,7 +1280,10 @@ function connectDevice(deviceId, webContents) {
             totalDiscovered: discoveredDevices.size,
             totalConnected: connectedDevices.size,
         });
-        let peripheral = (_a = discoveredDevices.get(deviceId)) !== null && _a !== void 0 ? _a : connectedDevices.get(deviceId);
+        let peripheral = (_a = connectedDevices.get(deviceId)) !== null && _a !== void 0 ? _a : discoveredDevices.get(deviceId);
+        if ((peripheral === null || peripheral === void 0 ? void 0 : peripheral.state) !== 'connected') {
+            peripheral = undefined;
+        }
         if (!peripheral) {
             if (!noble) {
                 yield initializeNoble();
@@ -1132,6 +1322,7 @@ function connectDevice(deviceId, webContents) {
                 peripheral = byIdFirst ? yield scanForPeripheral() : yield connectById();
             }
         }
+        assertBleActive();
         if (!peripheral) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found`);
         }
@@ -1142,6 +1333,7 @@ function connectDevice(deviceId, webContents) {
             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');
@@ -1166,6 +1358,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);
             }
@@ -1176,54 +1369,33 @@ 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);
-                    disconnectDevice(deviceId)
-                        .catch(() => undefined)
-                        .then(() => 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);
+        if (nativeReleased)
+            return;
+        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);
@@ -1247,6 +1419,8 @@ function disconnectDevice(deviceId) {
 }
 function unsubscribeNotifications(deviceId) {
     return index.__awaiter(this, void 0, void 0, function* () {
+        if (nativeReleased)
+            return;
         const peripheral = connectedDevices.get(deviceId);
         const characteristics = deviceCharacteristics.get(deviceId);
         if (!peripheral || !characteristics) {
@@ -1266,7 +1440,8 @@ function unsubscribeNotifications(deviceId) {
             subscribedDevices.delete(deviceId);
         }
         finally {
-            subscriptionOperations.set(deviceId, 'idle');
+            if (!disposing)
+                subscriptionOperations.set(deviceId, 'idle');
         }
     });
 }
@@ -1316,10 +1491,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);
@@ -1332,29 +1509,53 @@ 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;
+    let windowDestroyed = false;
     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 {
+                    if (windowCleanup)
+                        yield windowCleanup;
+                    assertBleActive();
+                    if (windowDestroyed) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, 'BLE window destroyed');
+                    }
+                    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* () {
             try {
-                const devices = yield enumerateDevices();
+                const devices = yield enumerateDevices(() => windowDestroyed);
                 safeLog(logger, 'debug', 'Enumeration completed', {
                     count: devices.length,
                     devices: devices.map(device => ({ id: device.id, name: device.name })),
@@ -1446,13 +1647,29 @@ function setupNobleBleHandlers(webContents) {
             }
         }));
         webContents.on('destroyed', () => {
+            windowDestroyed = true;
+            if (disposing)
+                return;
             safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
-            (() => index.__awaiter(this, void 0, void 0, function* () {
+            const previousCleanup = windowCleanup;
+            const enumerations = Array.from(pendingEnumerations, cancel => cancel());
+            windowCleanup = (() => index.__awaiter(this, void 0, void 0, function* () {
+                if (previousCleanup)
+                    yield previousCleanup;
+                yield Promise.allSettled(enumerations);
+                if (disposing)
+                    return;
                 const deviceIds = Array.from(connectedDevices.keys());
                 for (const deviceId of deviceIds) {
+                    if (disposing)
+                        return;
                     yield unsubscribeNotifications(deviceId).catch(() => undefined);
+                    if (disposing)
+                        return;
                     yield disconnectDevice(deviceId).catch(() => undefined);
                 }
+                if (disposing)
+                    return;
                 yield stopScanning().catch(() => undefined);
                 cleanupNobleListeners();
                 discoveredDevices.clear();
@@ -1468,6 +1685,77 @@ 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'));
+    }
+    const connections = Array.from(nativeConnections);
+    for (const connection of connections) {
+        try {
+            connection.cancel();
+        }
+        catch (error) {
+            logger === null || logger === void 0 ? void 0 : logger.warn('[NobleBLE] Native connect cancellation failed', error);
+        }
+    }
+    let timeout;
+    disposePromise = (() => index.__awaiter(this, void 0, void 0, function* () {
+        try {
+            yield Promise.race([
+                Promise.allSettled([
+                    windowCleanup,
+                    ...connections.map(connection => connection.settled),
+                    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);
+            nativeReleased = true;
+            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;