@onekeyfe/hd-transport-electron 1.2.8-alpha.131 → 1.2.8-alpha.133

package/dist/{index-f41d5fc1.js → index-5b7f7420.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-180255d0.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-a420607d.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-180255d0.js'); });
+        const handler = yield Promise.resolve().then(function () { return require('./noble-ble-handler-a420607d.js'); });
         yield handler.disposeNobleBleSupport(releaseNoble);
     });
 }

package/dist/index.js

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

package/dist/{noble-ble-handler-180255d0.js → noble-ble-handler-a420607d.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-f41d5fc1.js');
+var index = require('./index-5b7f7420.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -1224,6 +1224,8 @@ function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
 const DIRECT_CONNECT_TIMEOUT_MS = 2000;
 const DIRECT_CONNECT_COOLDOWN_MS = 15000;
 const directConnectCooldownUntil = new Map();
+const pendingDirectNativeConnections = new Set();
+const deviceConnectionPromises = new Map();
 function tryDirectConnectById(deviceId) {
     var _a;
     return index.__awaiter(this, void 0, void 0, function* () {
@@ -1231,6 +1233,8 @@ function tryDirectConnectById(deviceId) {
         const nobleInstance = noble;
         if (!(nobleInstance === null || nobleInstance === void 0 ? void 0 : nobleInstance.connectAsync))
             return undefined;
+        if (pendingDirectNativeConnections.has(deviceId))
+            return undefined;
         const cooldownUntil = (_a = directConnectCooldownUntil.get(deviceId)) !== null && _a !== void 0 ? _a : 0;
         if (Date.now() < cooldownUntil)
             return undefined;
@@ -1239,7 +1243,9 @@ function tryDirectConnectById(deviceId) {
         let abandoned = false;
         try {
             const directPromise = nobleInstance.connectAsync(deviceId);
-            trackNativeConnection(directPromise.then((late) => index.__awaiter(this, void 0, void 0, function* () {
+            pendingDirectNativeConnections.add(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);
@@ -1250,7 +1256,8 @@ function tryDirectConnectById(deviceId) {
                         timeoutBehavior: 'resolve',
                     });
                 }
-            })), () => { var _a; return (_a = nobleInstance.cancelConnect) === null || _a === void 0 ? void 0 : _a.call(nobleInstance, deviceId); });
+            }))
+                .finally(() => pendingDirectNativeConnections.delete(deviceId)), () => { 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 => {
@@ -1291,6 +1298,16 @@ function tryDirectConnectById(deviceId) {
     });
 }
 function connectDevice(deviceId, webContents) {
+    const pending = deviceConnectionPromises.get(deviceId);
+    if (pending)
+        return pending;
+    const connecting = connectDeviceOnce(deviceId, webContents).finally(() => {
+        deviceConnectionPromises.delete(deviceId);
+    });
+    deviceConnectionPromises.set(deviceId, connecting);
+    return connecting;
+}
+function connectDeviceOnce(deviceId, webContents) {
     var _a, _b, _c;
     return index.__awaiter(this, void 0, void 0, function* () {
         yield initializeNoble();

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,+CAG3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AA+KD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAi1DD,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,+CAG3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AA+KD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAm2DD,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.8-alpha.131",
+  "version": "1.2.8-alpha.133",
   "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.8-alpha.131",
-    "@onekeyfe/hd-shared": "1.2.8-alpha.131",
-    "@onekeyfe/hd-transport": "1.2.8-alpha.131",
+    "@onekeyfe/hd-core": "1.2.8-alpha.133",
+    "@onekeyfe/hd-shared": "1.2.8-alpha.133",
+    "@onekeyfe/hd-transport": "1.2.8-alpha.133",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "8368279d92c3ff3b04fd186a4fc890eba83305c8"
+  "gitHead": "c859b88e03cf7a80e3168ab048fd1af6cb286af6"
 }

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

@@ -1015,6 +1015,241 @@ describe('Noble BLE process shutdown', () => {
     expect(jest.getTimerCount()).toBe(0);
   });
 
+  test('keeps one native direct connection across repeated probe timeouts for the same device', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+    const { sdk, native, handlers } = await setup();
+    // Use Noble's real exclusive listeners without loading its native bindings.
+    const Noble = jest.requireActual('@stoprocent/noble/lib/noble');
+    const direct = new Noble({ connect: jest.fn(), cancelConnect: jest.fn() });
+    const connectAsync = jest.fn((id: string) => direct.connectAsync(id));
+    const cancelConnect = jest.fn((id: string) => direct.cancelConnect(id));
+    Object.assign(native, { connectAsync, cancelConnect });
+    const deviceId = 'aabbccddeeff';
+
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const connecting = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, deviceId);
+      await flushCallbacks();
+      jest.advanceTimersByTime(1500);
+      await flushCallbacks();
+      expect(connectAsync).toHaveBeenCalledTimes(1);
+      jest.advanceTimersByTime(2000);
+      await flushCallbacks();
+      expect(await connecting).toMatchObject({
+        success: false,
+        error: { errorCode: HardwareErrorCode.DeviceNotFound },
+      });
+      jest.advanceTimersByTime(15_000);
+    }
+
+    expect(cancelConnect).not.toHaveBeenCalled();
+    const disposing = sdk.disposeNobleBleSupport();
+    await flushCallbacks();
+    expect(native.stop).toHaveBeenCalledTimes(1);
+    await disposing;
+    expect(cancelConnect).toHaveBeenCalledTimes(1);
+    expect(direct.listenerCount(`connect:${deviceId}`)).toBe(0);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('cleans up native success arriving after the direct probe timeout', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+    const { sdk, native, handlers } = await setup();
+    const Noble = jest.requireActual('@stoprocent/noble/lib/noble');
+    const disconnect = jest.fn();
+    const direct = new Noble({ connect: jest.fn(), cancelConnect: jest.fn(), disconnect });
+    disconnect.mockImplementation((id: string) => direct._onDisconnect(id));
+    const peripheral = direct._createPeripheral(
+      'aabbccddeeff',
+      '',
+      '',
+      true,
+      { localName: 'OneKey Pro' },
+      0,
+      true
+    );
+    const cancelConnect = jest.fn((id: string) => direct.cancelConnect(id));
+    Object.assign(native, {
+      connectAsync: jest.fn((id: string) => direct.connectAsync(id)),
+      cancelConnect,
+    });
+    const connecting = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, peripheral.id);
+    await flushCallbacks();
+    jest.advanceTimersByTime(1500);
+    await flushCallbacks();
+    jest.advanceTimersByTime(2000);
+    await flushCallbacks();
+    expect(await connecting).toMatchObject({ success: false });
+
+    direct._onConnect(peripheral.id, null);
+    await flushCallbacks();
+    expect(disconnect).toHaveBeenCalledTimes(1);
+    expect(peripheral.state).toBe('disconnected');
+    await sdk.disposeNobleBleSupport();
+    expect(cancelConnect).not.toHaveBeenCalled();
+    expect(native.stop).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('retries unavailable native IDs after cooldown without retaining connections', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+    const { sdk, native, handlers } = await setup();
+    const Noble = jest.requireActual('@stoprocent/noble/lib/noble');
+    const connect = jest.fn(() => {
+      throw new Error('Peripheral could not be retrieved for connection');
+    });
+    const direct = new Noble({ connect, cancelConnect: jest.fn() });
+    const cancelConnect = jest.fn((id: string) => direct.cancelConnect(id));
+    Object.assign(native, {
+      connectAsync: jest.fn((id: string) => direct.connectAsync(id)),
+      cancelConnect,
+    });
+
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const connecting = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.(
+        {},
+        'aabbccddeeff'
+      );
+      await flushCallbacks();
+      jest.advanceTimersByTime(1500);
+      await flushCallbacks();
+      expect(await connecting).toMatchObject({ success: false });
+      expect(connect).toHaveBeenCalledTimes(attempt + 1);
+      expect(jest.getTimerCount()).toBe(0);
+      jest.advanceTimersByTime(15_000);
+    }
+
+    const disposing = sdk.disposeNobleBleSupport();
+    await flushCallbacks();
+    expect(native.stop).toHaveBeenCalledTimes(1);
+    await disposing;
+    expect(cancelConnect).not.toHaveBeenCalled();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test.each(['before', 'after'])(
+    'retries a direct connection that fails before discovery %s the probe timeout',
+    async phase => {
+      jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+      const { sdk, native, handlers } = await setup();
+      const Noble = jest.requireActual('@stoprocent/noble/lib/noble');
+      const bindings = Object.assign(new EventEmitter(), {
+        connect: jest.fn(),
+        cancelConnect: jest.fn(),
+      });
+      const direct = new Noble(bindings);
+      direct._registerListeners();
+      direct.removeAllListeners('warning');
+      direct.on('warning', jest.fn());
+      const connectAsync = jest.fn((id: string) => direct.connectAsync(id));
+      Object.assign(native, {
+        connectAsync,
+        cancelConnect: jest.fn((id: string) => direct.cancelConnect(id)),
+      });
+      const deviceId = 'aabbccddeeff';
+      let firstFinished = false;
+      const connecting = Promise.resolve(
+        handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, deviceId)
+      ).then(result => {
+        firstFinished = true;
+        return result;
+      });
+      await flushCallbacks();
+      jest.advanceTimersByTime(1500);
+      await flushCallbacks();
+      expect(connectAsync).toHaveBeenCalledTimes(1);
+      expect(direct._peripherals.has(deviceId)).toBe(false);
+      if (phase === 'after') {
+        jest.advanceTimersByTime(2000);
+        await flushCallbacks();
+      }
+      bindings.emit('connect', deviceId, new Error('native async connection failed'));
+      await flushCallbacks();
+      expect(firstFinished).toBe(true);
+      expect(await connecting).toMatchObject({ success: false });
+
+      jest.advanceTimersByTime(15_000);
+      const retry = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, deviceId);
+      await flushCallbacks();
+      jest.advanceTimersByTime(1500);
+      await flushCallbacks();
+      expect(connectAsync).toHaveBeenCalledTimes(2);
+      const disposing = sdk.disposeNobleBleSupport();
+      await flushCallbacks();
+      expect(native.stop).toHaveBeenCalledTimes(1);
+      await disposing;
+      expect(await retry).toMatchObject({ success: false });
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  );
+
+  test('shares concurrent connections instead of cancelling a newer direct probe', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+    const { sdk, native, handlers } = await setup();
+    const Noble = jest.requireActual('@stoprocent/noble/lib/noble');
+    const direct = new Noble({ connect: jest.fn(), cancelConnect: jest.fn() });
+    const connectAsync = jest.fn((id: string) => direct.connectAsync(id));
+    const cancelConnect = jest.fn((id: string) => direct.cancelConnect(id));
+    Object.assign(native, { connectAsync, cancelConnect });
+    const connect = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT);
+    const first = connect?.({}, 'aabbccddeeff');
+    await flushCallbacks();
+    jest.advanceTimersByTime(1500);
+    await flushCallbacks();
+    jest.advanceTimersByTime(500);
+    const second = connect?.({}, 'aabbccddeeff');
+    await flushCallbacks();
+    expect(native.startScanning).toHaveBeenCalledTimes(1);
+    jest.advanceTimersByTime(1500);
+    await flushCallbacks();
+    expect(await first).toMatchObject({ success: false });
+    expect(await second).toMatchObject({ success: false });
+    expect(connectAsync).toHaveBeenCalledTimes(1);
+    expect(cancelConnect).not.toHaveBeenCalled();
+
+    const disposing = sdk.disposeNobleBleSupport();
+    await flushCallbacks();
+    expect(native.stop).toHaveBeenCalledTimes(1);
+    await disposing;
+    expect(cancelConnect).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('keeps late direct connect cleanup without native cancellation support', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+    const { sdk, native, handlers } = await setup();
+    const peripheral = Object.assign(new EventEmitter(), {
+      ...createPeripheral('late-device', 'OneKey Pro'),
+      disconnect: jest.fn(callback => callback?.()),
+    });
+    let finishConnect: ((value: typeof peripheral) => void) | undefined;
+    Object.assign(native, {
+      connectAsync: jest.fn(
+        () =>
+          new Promise<typeof peripheral>(resolve => {
+            finishConnect = resolve;
+          })
+      ),
+    });
+    const connecting = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, peripheral.id);
+    await flushCallbacks();
+    jest.advanceTimersByTime(1500);
+    await flushCallbacks();
+    jest.advanceTimersByTime(2000);
+    await flushCallbacks();
+    expect(await connecting).toMatchObject({
+      success: false,
+      error: { errorCode: HardwareErrorCode.DeviceNotFound },
+    });
+
+    peripheral.state = 'connected';
+    finishConnect?.(peripheral);
+    await flushCallbacks();
+    expect(peripheral.disconnect).toHaveBeenCalledTimes(1);
+    await sdk.disposeNobleBleSupport();
+    expect(native.stop).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
   test('cancels native connects and waits for disconnect before release', async () => {
     const { sdk, native, handlers } = await setup();
     await handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
@@ -1446,3 +1681,76 @@ describe('Electron Noble BLE advertisement color', () => {
     ]);
   });
 });
+
+describe('Noble synchronous native connection failures', () => {
+  test.each(['direct', 'peripheral'] as const)(
+    'releases %s async connection listeners and permits a subsequent retry',
+    async entry => {
+      const Noble = jest.requireActual('@stoprocent/noble/lib/noble');
+      const error = new Error('Peripheral could not be retrieved for connection');
+      const bindings = { connect: jest.fn() };
+      const noble = new Noble(bindings);
+      noble.removeAllListeners('warning');
+      noble.on('warning', jest.fn());
+      const deviceId = 'aabbccddeeff';
+      const peripheral =
+        entry === 'peripheral'
+          ? noble._createPeripheral(deviceId, '', '', true, {}, 0, true)
+          : undefined;
+      bindings.connect.mockImplementationOnce(() => {
+        throw error;
+      });
+
+      await expect(
+        entry === 'direct' ? noble.connectAsync(deviceId) : peripheral.connectAsync()
+      ).rejects.toBe(error);
+      expect(noble.listenerCount(`connect:${deviceId}`)).toBe(0);
+      expect(noble._exclusiveCallbacks?.size ?? 0).toBe(0);
+      if (peripheral) {
+        expect(peripheral.state).toBe('error');
+        expect(peripheral.listenerCount('connect')).toBe(0);
+        expect(peripheral._exclusiveCallbacks.size).toBe(0);
+      }
+
+      const retryPeripheral =
+        peripheral ?? noble._createPeripheral(deviceId, '', '', true, {}, 0, true);
+      const retry =
+        entry === 'direct' ? noble.connectAsync(deviceId) : retryPeripheral.connectAsync();
+      noble._onConnect(deviceId);
+      await retry;
+      expect(retryPeripheral.state).toBe('connected');
+      expect(bindings.connect).toHaveBeenCalledTimes(2);
+      expect(noble.listenerCount(`connect:${deviceId}`)).toBe(0);
+      expect(retryPeripheral.listenerCount('connect')).toBe(0);
+    }
+  );
+
+  test.each(['direct', 'peripheral'] as const)(
+    'settles the %s callback once when the binding throws',
+    entry => {
+      const Noble = jest.requireActual('@stoprocent/noble/lib/noble');
+      const error = new Error('Peripheral could not be retrieved for connection');
+      const noble = new Noble({
+        connect: () => {
+          throw error;
+        },
+      });
+      const deviceId = 'aabbccddeeff';
+      const peripheral = noble._createPeripheral(deviceId, '', '', true, {}, 0, true);
+      const callback = jest.fn();
+
+      expect(() =>
+        entry === 'direct'
+          ? noble.connect(deviceId, undefined, callback)
+          : peripheral.connect(undefined, callback)
+      ).not.toThrow();
+      expect(callback).toHaveBeenCalledTimes(1);
+      expect(callback.mock.calls[0][0]).toBe(error);
+      expect(peripheral.state).toBe('error');
+      expect(noble.listenerCount(`connect:${deviceId}`)).toBe(0);
+      expect(peripheral.listenerCount('connect')).toBe(0);
+      noble._onConnect(deviceId, error);
+      expect(callback).toHaveBeenCalledTimes(1);
+    }
+  );
+});

package/src/noble-ble-handler.ts

@@ -1698,11 +1698,13 @@ async function setupConnectionAndDiscoverServices(
   }
 }
 
-// noble/mac never resolves for an id CoreBluetooth cannot retrieve.
+// Bound probes while a native backend is still waiting for the device.
 const DIRECT_CONNECT_TIMEOUT_MS = 2000;
 // Floor after a timeout: do not pay the probe on every attempt.
 const DIRECT_CONNECT_COOLDOWN_MS = 15_000;
 const directConnectCooldownUntil = new Map<string, number>();
+const pendingDirectNativeConnections = new Set<string>();
+const deviceConnectionPromises = new Map<string, Promise<void>>();
 
 /**
  * Connect straight by id, skipping the ~650ms targeted scan. Both native
@@ -1721,6 +1723,8 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
     | null;
   if (!nobleInstance?.connectAsync) return undefined;
 
+  // Retain the original listener and late cleanup until the native attempt settles.
+  if (pendingDirectNativeConnections.has(deviceId)) return undefined;
   const cooldownUntil = directConnectCooldownUntil.get(deviceId) ?? 0;
   if (Date.now() < cooldownUntil) return undefined;
 
@@ -1730,18 +1734,21 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
   try {
     // The late-orphan guard must attach to THIS pending connect.
     const directPromise = nobleInstance.connectAsync(deviceId);
+    pendingDirectNativeConnections.add(deviceId);
     trackNativeConnection(
-      directPromise.then(async late => {
-        if ((!abandoned && !disposing) || nativeReleased) return;
-        const peripheral = late ?? discoveredDevices.get(deviceId);
-        if (peripheral?.state === 'connected' && !connectedDevices.has(deviceId)) {
-          peripheral.removeAllListeners('disconnect');
-          await runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
-            timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
-            timeoutBehavior: 'resolve',
-          });
-        }
-      }),
+      directPromise
+        .then(async late => {
+          if ((!abandoned && !disposing) || nativeReleased) return;
+          const peripheral = late ?? discoveredDevices.get(deviceId);
+          if (peripheral?.state === 'connected' && !connectedDevices.has(deviceId)) {
+            peripheral.removeAllListeners('disconnect');
+            await runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+              timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+              timeoutBehavior: 'resolve',
+            });
+          }
+        })
+        .finally(() => pendingDirectNativeConnections.delete(deviceId)),
       () => nobleInstance.cancelConnect?.(deviceId)
     );
     const raced = await Promise.race([
@@ -1781,7 +1788,18 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
 }
 
 // Connect to device - supports both discovered and direct connection modes
-async function connectDevice(deviceId: string, webContents: WebContents): Promise<void> {
+function connectDevice(deviceId: string, webContents: WebContents): Promise<void> {
+  // Share the whole attempt so a scan fallback cannot race another caller's native probe.
+  const pending = deviceConnectionPromises.get(deviceId);
+  if (pending) return pending;
+  const connecting = connectDeviceOnce(deviceId, webContents).finally(() => {
+    deviceConnectionPromises.delete(deviceId);
+  });
+  deviceConnectionPromises.set(deviceId, connecting);
+  return connecting;
+}
+
+async function connectDeviceOnce(deviceId: string, webContents: WebContents): Promise<void> {
   await initializeNoble();
   logger?.info('[NobleBLE] Connect device request:', {
     deviceId,