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

package/dist/{index-d51c7da6.js → index-8e6acfc1.js}

@@ -30,12 +30,44 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function isNobleBleIpcErrorResponse(response) {
+    var _a;
+    if (!response || typeof response !== 'object') {
+        return false;
+    }
+    const candidate = response;
+    return (candidate.type === 'NobleBleIpcError' &&
+        candidate.success === false &&
+        Boolean(candidate.error) &&
+        typeof ((_a = candidate.error) === null || _a === void 0 ? void 0 : _a.name) === 'string' &&
+        typeof candidate.error.message === 'string' &&
+        typeof candidate.error.errorCode === 'number');
+}
+function invokeNobleBleIpc(request) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield request;
+        if (isNobleBleIpcErrorResponse(response)) {
+            return Promise.reject(response.error);
+        }
+        return response;
+    });
+}
+
 function initNobleBleSupport(webContents) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-0b455c4f.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-3a1d131d.js'); });
         setupNobleBleHandlers(webContents);
     });
 }
+function disposeNobleBleSupport(releaseNoble) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const handler = yield Promise.resolve().then(function () { return require('./noble-ble-handler-3a1d131d.js'); });
+        yield handler.disposeNobleBleSupport(releaseNoble);
+    });
+}
 
 exports.__awaiter = __awaiter;
+exports.disposeNobleBleSupport = disposeNobleBleSupport;
 exports.initNobleBleSupport = initNobleBleSupport;
+exports.invokeNobleBleIpc = invokeNobleBleIpc;
+exports.isNobleBleIpcErrorResponse = isNobleBleIpcErrorResponse;

package/dist/index.d.ts

@@ -17,6 +17,7 @@ interface NobleModule {
     state: string;
     startScanning(serviceUUIDs: string[], allowDuplicates: boolean, callback?: (error?: Error) => void): void;
     stopScanning(callback?: () => void): void;
+    stop(): void;
     on(event: 'stateChange', listener: (state: string) => void): void;
     on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
     removeListener(event: 'stateChange', listener: (state: string) => void): void;
@@ -48,6 +49,12 @@ type NobleBleIpcErrorResponse = {
     success: false;
     error: NobleBleIpcErrorPayload;
 };
+declare function isNobleBleIpcErrorResponse(response: unknown): response is NobleBleIpcErrorResponse;
+/**
+ * Keeps structured Noble errors intact across Electron's IPC and contextBridge
+ * boundaries. Every preload implementation must use this for Noble invokes.
+ */
+declare function invokeNobleBleIpc<T>(request: Promise<T | NobleBleIpcErrorResponse>): Promise<T>;
 interface NobleBleAPI {
     enumerate: () => Promise<{
         id: string;
@@ -92,5 +99,9 @@ interface DesktopAPI {
 }
 
 declare function initNobleBleSupport(webContents: WebContents): Promise<void>;
+/** Terminal process cleanup. A host sharing Noble can defer native stop until all users are idle. */
+declare function disposeNobleBleSupport(releaseNoble?: (noble: {
+    stop(): void;
+}) => void): Promise<void>;
 
-export { CharacteristicPair, DesktopAPI, DeviceInfo, Logger, NobleBleAPI, NobleBleIpcErrorPayload, NobleBleIpcErrorResponse, NobleBleWriteOptions, NobleModule, initNobleBleSupport };
+export { CharacteristicPair, DesktopAPI, DeviceInfo, Logger, NobleBleAPI, NobleBleIpcErrorPayload, NobleBleIpcErrorResponse, NobleBleWriteOptions, NobleModule, disposeNobleBleSupport, initNobleBleSupport, invokeNobleBleIpc, isNobleBleIpcErrorResponse };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,cAAc,SAAS,CAAC;AAGxB,YAAY,EACV,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAE7B,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,WAAW,iBAGjE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,cAAc,SAAS,CAAC;AAGxB,YAAY,EACV,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEpF,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,WAAW,iBAGjE;AAGD,wBAAsB,sBAAsB,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,KAAK,IAAI,iBAG5F"}

package/dist/index.js

@@ -2,8 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-d51c7da6.js');
+var index = require('./index-8e6acfc1.js');
 
 
 
+exports.disposeNobleBleSupport = index.disposeNobleBleSupport;
 exports.initNobleBleSupport = index.initNobleBleSupport;
+exports.invokeNobleBleIpc = index.invokeNobleBleIpc;
+exports.isNobleBleIpcErrorResponse = index.isNobleBleIpcErrorResponse;

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-d51c7da6.js');
+var index = require('./index-8e6acfc1.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -100,9 +100,19 @@ 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';
+    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})`, {
@@ -143,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();
@@ -281,6 +342,7 @@ function updateBluetoothState(state) {
 }
 function initializeNoble() {
     return index.__awaiter(this, void 0, void 0, function* () {
+        assertBleActive();
         if (noble)
             return;
         try {
@@ -297,9 +359,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);
@@ -324,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);
@@ -372,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);
@@ -407,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,
@@ -421,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);
@@ -499,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) {
@@ -701,6 +776,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');
         }
@@ -712,6 +788,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);
@@ -721,6 +798,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);
                 }
@@ -740,6 +818,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) {
@@ -759,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);
@@ -788,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);
@@ -853,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(() => {
@@ -872,6 +969,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* () {
@@ -886,6 +984,7 @@ function discoverServicesAndCharacteristics(peripheral) {
                     }
                 });
             });
+            assertBleActive();
             if (!services || services.length === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
             }
@@ -958,17 +1057,8 @@ function forceReconnectPeripheral(peripheral, deviceId) {
                 callback();
             }), { timeoutMs: BLE_CLEANUP_TIMEOUT, timeoutBehavior: 'resolve' });
         }
-        yield new Promise((resolve, reject) => {
-            peripheral.connect(error => {
-                if (error) {
-                    reject(createNobleBleConnectionError(error));
-                    return;
-                }
-                resolve();
-            });
-        });
+        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);
     });
 }
@@ -985,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(createNobleBleConnectionError(error, 'Fresh peripheral connection failed: '));
-                }
-                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');
@@ -1034,6 +1114,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,
@@ -1049,11 +1130,13 @@ function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
             yield forceReconnectPeripheral(peripheral, deviceId);
         }
         catch (resetError) {
-            if (hdShared.isBleStaleBondHardwareError(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);
@@ -1076,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,
@@ -1122,6 +1210,11 @@ function tryDirectConnectById(deviceId) {
             });
             return undefined;
         }
+        finally {
+            clearTimeout(timer);
+            if (cancel)
+                pendingCancellations.delete(cancel);
+        }
     });
 }
 function connectDevice(deviceId, webContents) {
@@ -1174,6 +1267,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`);
         }
@@ -1184,6 +1278,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');
@@ -1208,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);
             }
@@ -1218,38 +1314,31 @@ function connectDevice(deviceId, webContents) {
             }
             return;
         }
-        return new Promise((resolve, reject) => {
-            const connectedPeripheral = peripheral;
-            connectedPeripheral.connect((error) => index.__awaiter(this, void 0, void 0, function* () {
-                if (error) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection failed:', error);
-                    reject(createNobleBleConnectionError(error));
-                    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);
+        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);
@@ -1292,7 +1381,8 @@ function unsubscribeNotifications(deviceId) {
             subscribedDevices.delete(deviceId);
         }
         finally {
-            subscriptionOperations.set(deviceId, 'idle');
+            if (!disposing)
+                subscriptionOperations.set(deviceId, 'idle');
         }
     });
 }
@@ -1342,10 +1432,12 @@ function subscribeNotifications(deviceId, callback) {
                     timeoutMs: BLE_CLEANUP_TIMEOUT,
                     timeoutBehavior: 'resolve',
                 });
+                assertBleActive();
                 yield runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
                     timeoutMs: NOBLE_BLE_SUBSCRIBE_TIMEOUT_MS,
                     timeoutBehavior: 'reject',
                 });
+                assertBleActive();
                 notifyCharacteristic.on('data', (data) => {
                     if (!pairedDevices.has(deviceId)) {
                         pairedDevices.add(deviceId);
@@ -1358,25 +1450,36 @@ 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, (...args) => index.__awaiter(this, void 0, void 0, function* () {
                 try {
+                    assertBleActive();
                     return yield Promise.resolve(listener(...args));
                 }
                 catch (error) {
@@ -1479,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());
@@ -1501,8 +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;