@onekeyfe/hd-transport-electron 1.2.3-alpha.1 → 1.2.3-alpha.10

package/dist/{index-985e2bf3.js → index-e2e3d2ba.js}

@@ -55,13 +55,13 @@ function invokeNobleBleIpc(request) {
 
 function initNobleBleSupport(webContents) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-263d4736.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-d0991fa0.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-263d4736.js'); });
+        const handler = yield Promise.resolve().then(function () { return require('./noble-ble-handler-d0991fa0.js'); });
         yield handler.disposeNobleBleSupport(releaseNoble);
     });
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-985e2bf3.js');
+var index = require('./index-e2e3d2ba.js');
 
 
 

package/dist/{noble-ble-handler-263d4736.js → noble-ble-handler-d0991fa0.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-985e2bf3.js');
+var index = require('./index-e2e3d2ba.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -123,8 +123,7 @@ function assertBleActive() {
 }
 function createNobleBleConnectionError(error, messagePrefix = '') {
     const errorMessage = error.message;
-    const isInvalidMacOsBond = (error.nativeErrorCode === 14 && error.nativeErrorDomain === 'CBErrorDomain') ||
-        (error.nativeErrorCode === 15 && error.nativeErrorDomain === 'CBATTErrorDomain');
+    const isInvalidMacOsBond = error.nativeErrorCode === 14 && error.nativeErrorDomain === 'CBErrorDomain';
     if (isInvalidMacOsBond) {
         const nativeErrorMessage = `${messagePrefix}${errorMessage}`;
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, `${hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleBondInvalid]} (${nativeErrorMessage})`, {
@@ -887,7 +886,6 @@ function enumerateDevices(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 = [];
@@ -1256,11 +1254,15 @@ function tryDirectConnectById(deviceId) {
             return peripheral;
         }
         catch (error) {
-            directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id failed, falling back to scan', {
                 deviceId,
                 error: String(error),
             });
+            const nativeError = error;
+            if (nativeError.nativeErrorCode === 14 && nativeError.nativeErrorDomain === 'CBErrorDomain') {
+                throw createNobleBleConnectionError(nativeError);
+            }
+            directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
             return undefined;
         }
         finally {
@@ -1281,7 +1283,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();
@@ -1308,17 +1313,29 @@ function connectDevice(deviceId, webContents) {
                     return undefined;
                 }
             });
+            let staleBondError;
             const connectById = () => index.__awaiter(this, void 0, void 0, function* () {
-                const found = yield tryDirectConnectById(deviceId);
-                if (found) {
-                    discoveredDevices.set(deviceId, found);
+                try {
+                    const found = yield tryDirectConnectById(deviceId);
+                    if (found) {
+                        discoveredDevices.set(deviceId, found);
+                    }
+                    return found;
+                }
+                catch (error) {
+                    if (error.errorCode !== hdShared.HardwareErrorCode.BleBondInvalid) {
+                        throw error;
+                    }
+                    staleBondError = error;
+                    return undefined;
                 }
-                return found;
             });
             peripheral = byIdFirst ? yield connectById() : yield scanForPeripheral();
             if (!peripheral) {
                 peripheral = byIdFirst ? yield scanForPeripheral() : yield connectById();
             }
+            if (!peripheral && staleBondError)
+                throw staleBondError;
         }
         assertBleActive();
         if (!peripheral) {
@@ -1515,7 +1532,12 @@ function subscribeNotifications(deviceId, callback) {
             });
         }
         catch (error) {
-            throw createNobleBleConnectionError(error, 'Notification subscription failed: ');
+            const nativeError = error;
+            if (nativeError.nativeErrorCode === 15 &&
+                nativeError.nativeErrorDomain === 'CBATTErrorDomain') {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleDeviceNotBonded], { nativeErrorMessage: `Notification subscription failed: ${nativeError.message}` });
+            }
+            throw createNobleBleConnectionError(nativeError, 'Notification subscription failed: ');
         }
         finally {
             if (!disposing)

package/dist/noble-ble-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAiC1F,KAAK,mBAAmB,GAAG,KAAK,GAAG;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,mBAAmB,EAAE,aAAa,SAAK,+CAiB3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AA+KD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAkyDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkOpE;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,GAAE,CAAC,QAAQ,EAAE;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,KAAK,IAAkC,GAC/E,OAAO,CAAC,IAAI,CAAC,CAiEf"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAiC1F,KAAK,mBAAmB,GAAG,KAAK,GAAG;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,mBAAmB,EAAE,aAAa,SAAK,+CAgB3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AA+KD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AA2zDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkOpE;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,GAAE,CAAC,QAAQ,EAAE;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,KAAK,IAAkC,GAC/E,OAAO,CAAC,IAAI,CAAC,CAiEf"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.2.3-alpha.1",
+  "version": "1.2.3-alpha.10",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -25,9 +25,9 @@
     "electron-log": ">=4.0.0"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.3-alpha.1",
-    "@onekeyfe/hd-shared": "1.2.3-alpha.1",
-    "@onekeyfe/hd-transport": "1.2.3-alpha.1",
+    "@onekeyfe/hd-core": "1.2.3-alpha.10",
+    "@onekeyfe/hd-shared": "1.2.3-alpha.10",
+    "@onekeyfe/hd-transport": "1.2.3-alpha.10",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "fd4221863c00240fc4870fc50f8c517d97426de2"
+  "gitHead": "2295285a846281941c21955684281446f587d993"
 }

package/src/__tests__/noble-ble-handler.test.ts

@@ -68,7 +68,7 @@ describe('Electron Noble BLE device discovery', () => {
         })
       )
     ).toMatchObject({
-      errorCode: HardwareErrorCode.BleBondInvalid,
+      errorCode: HardwareErrorCode.BleConnectedError,
     });
     expect(createNobleBleConnectionError(new Error('connection failed'))).toMatchObject({
       errorCode: HardwareErrorCode.BleConnectedError,
@@ -225,6 +225,214 @@ describe('Electron Noble BLE device discovery', () => {
     ]);
   });
 
+  test.each(['Pro A1B2', 'Pro2 A1B2'])(
+    'retains %s across scan rounds until Bluetooth is powered off',
+    async name => {
+      jest.useFakeTimers({ doNotFake: ['performance'] });
+
+      const handlers = new Map<string, IpcHandler>();
+      const ipcMain = {
+        handle: jest.fn((channel: string, handler: IpcHandler) => {
+          handlers.set(channel, handler);
+        }),
+        removeHandler: jest.fn((channel: string) => {
+          handlers.delete(channel);
+        }),
+      };
+      const noble = Object.assign(new EventEmitter(), {
+        state: 'poweredOn',
+        startScanning: jest.fn(),
+        stopScanning: jest.fn(callback => callback?.()),
+      });
+
+      jest.doMock('@stoprocent/noble', () => noble);
+      jest.doMock('electron', () => ({ ipcMain }));
+      jest.doMock('electron-log', () => ({
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      }));
+
+      const { setupNobleBleHandlers } = await import('../noble-ble-handler');
+      setupNobleBleHandlers({
+        on: jest.fn(),
+        send: jest.fn(),
+      } as unknown as WebContents);
+
+      const enumerate = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE);
+      if (!enumerate) {
+        throw new Error('Electron Noble BLE enumerate handler was not registered');
+      }
+
+      const scan = async (peripherals: ReturnType<typeof createPeripheral>[]) => {
+        let resolveScanStarted = () => undefined;
+        const scanStarted = new Promise<void>(resolve => {
+          resolveScanStarted = resolve;
+        });
+        noble.startScanning.mockImplementationOnce((_services, _duplicates, callback) => {
+          callback?.();
+          peripherals.forEach(peripheral => noble.emit('discover', peripheral));
+          resolveScanStarted();
+        });
+        const devices = Promise.resolve(enumerate());
+        await scanStarted;
+        jest.advanceTimersByTime(5_000);
+        return devices;
+      };
+
+      const firstDevice = createPeripheral('first-device', name);
+      const secondDevice = createPeripheral('second-device', 'Pro2 C3D4');
+      await expect(scan([firstDevice])).resolves.toEqual([
+        expect.objectContaining({ id: 'first-device', name }),
+      ]);
+      await expect(scan([secondDevice, secondDevice])).resolves.toEqual([
+        expect.objectContaining({ id: 'first-device', name }),
+        expect.objectContaining({ id: 'second-device', name: 'Pro2 C3D4' }),
+      ]);
+      await expect(scan([])).resolves.toHaveLength(2);
+
+      noble.state = 'poweredOff';
+      noble.emit('stateChange', 'poweredOff');
+      noble.state = 'poweredOn';
+      noble.emit('stateChange', 'poweredOn');
+      await expect(scan([])).resolves.toEqual([]);
+    }
+  );
+
+  test.each(['Pro A1B2', 'Pro2 A1B2'])(
+    'refreshes a retained disconnected %s peripheral before cold connecting',
+    async name => {
+      const handlers = new Map<string, IpcHandler>();
+      const stalePeripheral = Object.assign(new EventEmitter(), createPeripheral('device', name), {
+        connect: jest.fn(),
+      });
+      const freshPeripheral = Object.assign(new EventEmitter(), createPeripheral('device', name), {
+        connect: jest.fn((callback: (error?: Error) => void) => {
+          callback(new Error('expected fresh connection failure'));
+        }),
+      });
+      const noble = Object.assign(new EventEmitter(), {
+        state: 'poweredOn',
+        startScanning: jest.fn((_services, _duplicates, callback) => {
+          callback?.();
+          noble.emit('discover', freshPeripheral);
+        }),
+        stopScanning: jest.fn(callback => callback?.()),
+        connectAsync: jest.fn(() => Promise.resolve(undefined)),
+      });
+      jest.doMock('@stoprocent/noble', () => noble);
+      jest.doMock('electron', () => ({
+        ipcMain: {
+          handle: (channel: string, handler: IpcHandler) => handlers.set(channel, handler),
+          removeHandler: (channel: string) => handlers.delete(channel),
+        },
+      }));
+      jest.doMock('electron-log', () => ({
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      }));
+      const { setupNobleBleHandlers } = await import('../noble-ble-handler');
+      setupNobleBleHandlers({ on: jest.fn(), send: jest.fn() } as unknown as WebContents);
+      const availability = handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK);
+      const connect = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT);
+      if (!availability || !connect) throw new Error('Noble handlers were not registered');
+      await availability();
+      noble.emit('discover', stalePeripheral);
+
+      await expect(Promise.resolve(connect(undefined, stalePeripheral.id))).resolves.toMatchObject({
+        success: false,
+        error: { message: 'expected fresh connection failure' },
+      });
+
+      expect(stalePeripheral.connect).not.toHaveBeenCalled();
+      expect(freshPeripheral.connect).toHaveBeenCalledTimes(1);
+      expect(noble.startScanning).toHaveBeenCalledTimes(1);
+      expect(noble.connectAsync).toHaveBeenCalledTimes(name.startsWith('Pro2') ? 1 : 0);
+    }
+  );
+
+  test.each([
+    { rediscovered: false, expectedCode: HardwareErrorCode.BleBondInvalid },
+    { rediscovered: true, expectedCode: HardwareErrorCode.BleConnectedError },
+  ])(
+    'reports a macOS stale bond only when fallback scan misses (rediscovered=$rediscovered)',
+    async ({ rediscovered, expectedCode }) => {
+      jest.useFakeTimers({ doNotFake: ['performance'] });
+      const handlers = new Map<string, IpcHandler>();
+      const stalePeripheral = createPeripheral('device', 'Pro2 A1B2');
+      const freshPeripheral = Object.assign(
+        new EventEmitter(),
+        createPeripheral('device', 'Pro2 A1B2'),
+        {
+          connect: jest.fn((callback: (error?: Error) => void) => {
+            callback(new Error('fresh connection failed'));
+          }),
+        }
+      );
+      const staleBondError = Object.assign(new Error('Peer removed pairing information'), {
+        nativeErrorCode: 14,
+        nativeErrorDomain: 'CBErrorDomain',
+      });
+      let scanStarted: (() => void) | undefined;
+      const scanning = new Promise<void>(resolve => {
+        scanStarted = resolve;
+      });
+      const noble = Object.assign(new EventEmitter(), {
+        state: 'poweredOn',
+        startScanning: jest.fn((_services, _duplicates, callback) => {
+          callback?.();
+          if (rediscovered) noble.emit('discover', freshPeripheral);
+          scanStarted?.();
+        }),
+        stopScanning: jest.fn(callback => callback?.()),
+        connectAsync: jest.fn(() => Promise.reject(staleBondError)),
+      });
+      jest.doMock('@stoprocent/noble', () => noble);
+      jest.doMock('electron', () => ({
+        ipcMain: {
+          handle: (channel: string, handler: IpcHandler) => handlers.set(channel, handler),
+          removeHandler: (channel: string) => handlers.delete(channel),
+        },
+      }));
+      jest.doMock('electron-log', () => ({
+        info: jest.fn(),
+        debug: jest.fn(),
+        error: jest.fn(),
+      }));
+      const { setupNobleBleHandlers } = await import('../noble-ble-handler');
+      setupNobleBleHandlers({ on: jest.fn(), send: jest.fn() } as unknown as WebContents);
+      const availability = handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK);
+      const connect = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT);
+      if (!availability || !connect) throw new Error('Noble handlers were not registered');
+      await availability();
+      noble.emit('discover', stalePeripheral);
+
+      const connecting = Promise.resolve(connect(undefined, stalePeripheral.id));
+      await scanning;
+      jest.advanceTimersByTime(1500);
+      await expect(connecting).resolves.toMatchObject({
+        success: false,
+        error: { errorCode: expectedCode },
+      });
+      if (!rediscovered) {
+        const secondScan = new Promise<void>(resolve => {
+          scanStarted = resolve;
+        });
+        const retry = Promise.resolve(connect(undefined, stalePeripheral.id));
+        await secondScan;
+        jest.advanceTimersByTime(1500);
+        await expect(retry).resolves.toMatchObject({
+          success: false,
+          error: { errorCode: HardwareErrorCode.BleBondInvalid },
+        });
+      }
+      expect(noble.connectAsync).toHaveBeenCalledTimes(rediscovered ? 1 : 2);
+      expect(noble.startScanning).toHaveBeenCalledTimes(rediscovered ? 1 : 2);
+      expect(freshPeripheral.connect).toHaveBeenCalledTimes(rediscovered ? 1 : 0);
+    }
+  );
+
   test('waits for a targeted scan to stop before connecting', async () => {
     jest.useFakeTimers({ doNotFake: ['performance'] });
 
@@ -578,7 +786,7 @@ describe('Electron Noble BLE device discovery', () => {
         type: 'NobleBleIpcError',
         success: false,
         error: {
-          errorCode: HardwareErrorCode.BleBondInvalid,
+          errorCode: HardwareErrorCode.BleDeviceNotBonded,
           params: {
             nativeErrorMessage: 'Notification subscription failed: Encryption is insufficient',
           },
@@ -846,9 +1054,12 @@ describe('Noble BLE process shutdown', () => {
       discoverServices: jest.fn(),
     });
     native.emit('discover', peripheral);
+    native.startScanning.mockImplementationOnce((_uuids, _duplicates, callback) => {
+      callback?.();
+      native.emit('discover', peripheral);
+    });
     const connecting = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, peripheral.id);
-    await Promise.resolve();
-    await Promise.resolve();
+    await flushCallbacks();
     expect(peripheral.connect).toHaveBeenCalledTimes(1);
     const disposing = sdk.disposeNobleBleSupport();
     await flushCallbacks();
@@ -886,7 +1097,13 @@ describe('Noble BLE process shutdown', () => {
       );
       const cancelConnect = jest.fn();
       if (route === 'direct') Object.assign(native, { connectAsync, cancelConnect });
-      else native.emit('discover', peripheral);
+      else {
+        native.emit('discover', peripheral);
+        native.startScanning.mockImplementationOnce((_uuids, _duplicates, callback) => {
+          callback?.();
+          native.emit('discover', peripheral);
+        });
+      }
       const connecting = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, peripheral.id);
       await flushCallbacks();
       if (route === 'direct') {

package/src/noble-ble-handler.ts

@@ -75,8 +75,7 @@ type NobleBleNativeError = Error & {
 export function createNobleBleConnectionError(error: NobleBleNativeError, messagePrefix = '') {
   const errorMessage = error.message;
   const isInvalidMacOsBond =
-    (error.nativeErrorCode === 14 && error.nativeErrorDomain === 'CBErrorDomain') ||
-    (error.nativeErrorCode === 15 && error.nativeErrorDomain === 'CBATTErrorDomain');
+    error.nativeErrorCode === 14 && error.nativeErrorDomain === 'CBErrorDomain';
   if (isInvalidMacOsBond) {
     const nativeErrorMessage = `${messagePrefix}${errorMessage}`;
     return ERRORS.TypedError(
@@ -1167,8 +1166,7 @@ async function enumerateDevices(isWindowDestroyed: () => boolean): Promise<Devic
 
   logger?.info('[NobleBLE] Starting device enumeration');
 
-  // Clear previous discoveries
-  discoveredDevices.clear();
+  // Keep prior discoveries when a polling round misses an advertisement.
 
   // Ensure discover listener is properly set up before scanning
   // This is crucial to fix the issue where devices are not found after web-usb failures
@@ -1743,11 +1741,15 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
     logger?.info('[NobleBLE] Direct connect-by-id succeeded', { deviceId });
     return peripheral;
   } catch (error) {
-    directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
     logger?.info('[NobleBLE] Direct connect-by-id failed, falling back to scan', {
       deviceId,
       error: String(error),
     });
+    const nativeError = error as NobleBleNativeError;
+    if (nativeError.nativeErrorCode === 14 && nativeError.nativeErrorDomain === 'CBErrorDomain') {
+      throw createNobleBleConnectionError(nativeError);
+    }
+    directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
     return undefined;
   } finally {
     clearTimeout(timer);
@@ -1766,8 +1768,12 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     totalConnected: connectedDevices.size,
   });
 
-  // enumerate clears the discovery map; a kept-alive link outlives it.
-  let peripheral = discoveredDevices.get(deviceId) ?? connectedDevices.get(deviceId);
+  // Retained discoveries are display metadata, not proof of a reusable native link.
+  // Prefer the live connection when an older discovery exists for the same device.
+  let peripheral = connectedDevices.get(deviceId) ?? discoveredDevices.get(deviceId);
+  if (peripheral?.state !== 'connected') {
+    peripheral = undefined;
+  }
 
   if (!peripheral) {
     // Initialize Noble if not already done
@@ -1806,12 +1812,21 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       }
     };
 
+    let staleBondError: Error | undefined;
     const connectById = async () => {
-      const found = await tryDirectConnectById(deviceId);
-      if (found) {
-        discoveredDevices.set(deviceId, found);
+      try {
+        const found = await tryDirectConnectById(deviceId);
+        if (found) {
+          discoveredDevices.set(deviceId, found);
+        }
+        return found;
+      } catch (error) {
+        if ((error as { errorCode?: number }).errorCode !== HardwareErrorCode.BleBondInvalid) {
+          throw error;
+        }
+        staleBondError = error as Error;
+        return undefined;
       }
-      return found;
     };
 
     peripheral = byIdFirst ? await connectById() : await scanForPeripheral();
@@ -1820,6 +1835,7 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       // silent), or not reachable by id. Try the other one before giving up.
       peripheral = byIdFirst ? await scanForPeripheral() : await connectById();
     }
+    if (!peripheral && staleBondError) throw staleBondError;
   }
 
   assertBleActive();
@@ -2117,10 +2133,18 @@ async function subscribeNotifications(
       ms: Date.now() - subscribeStartedAt,
     });
   } catch (error) {
-    throw createNobleBleConnectionError(
-      error as NobleBleNativeError,
-      'Notification subscription failed: '
-    );
+    const nativeError = error as NobleBleNativeError;
+    if (
+      nativeError.nativeErrorCode === 15 &&
+      nativeError.nativeErrorDomain === 'CBATTErrorDomain'
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.BleDeviceNotBonded,
+        HardwareErrorCodeMessage[HardwareErrorCode.BleDeviceNotBonded],
+        { nativeErrorMessage: `Notification subscription failed: ${nativeError.message}` }
+      );
+    }
+    throw createNobleBleConnectionError(nativeError, 'Notification subscription failed: ');
   } finally {
     // 🔒 CRITICAL: Always clear operation state (even on error)
     if (!disposing) subscriptionOperations.set(deviceId, 'idle');