@ukeyfe/hardware-transport-electron 1.1.13

package/dist/noble-ble-handler-37d3b074.js

@@ -0,0 +1,1214 @@
+'use strict';
+
+var index = require('./index-60176982.js');
+var hardwareShared = require('@ukeyfe/hardware-shared');
+var hardwareTransport = require('@ukeyfe/hardware-transport');
+var pRetry = require('p-retry');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var pRetry__default = /*#__PURE__*/_interopDefaultLegacy(pRetry);
+
+function safeLog(logger, level, message, ...args) {
+    if (logger) {
+        logger[level](message, ...args);
+    }
+    else {
+        console[level](`[NobleBLE] ${message}`, ...args);
+    }
+}
+
+function softRefreshSubscription(params) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const { deviceId, notifyCharacteristic, subscriptionOperations, subscribedDevices, pairedDevices, notificationCallbacks, processNotificationData, logger, } = params;
+        if (!notifyCharacteristic) {
+            throw new Error(`Notify characteristic not available for device ${deviceId}`);
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info('[BLE-OPS] Starting subscription refresh', { deviceId });
+        subscriptionOperations.set(deviceId, 'subscribing');
+        yield new Promise(resolve => {
+            notifyCharacteristic.unsubscribe(() => resolve());
+        });
+        yield new Promise((resolve, reject) => {
+            notifyCharacteristic.subscribe((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        notifyCharacteristic.removeAllListeners('data');
+        notifyCharacteristic.on('data', (data) => {
+            if (!pairedDevices.has(deviceId)) {
+                pairedDevices.add(deviceId);
+                logger === null || logger === void 0 ? void 0 : logger.info('[BLE-OPS] Device paired successfully', { deviceId });
+            }
+            const result = processNotificationData(deviceId, data);
+            if (result.error) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[BLE-OPS] Packet processing error:', result.error);
+                return;
+            }
+            if (result.isComplete && result.completePacket) {
+                const appCb = notificationCallbacks.get(deviceId);
+                if (appCb)
+                    appCb(result.completePacket);
+            }
+        });
+        subscribedDevices.set(deviceId, true);
+        subscriptionOperations.set(deviceId, 'idle');
+        logger === null || logger === void 0 ? void 0 : logger.info('[BLE-OPS] Subscription refresh completed', { deviceId });
+    });
+}
+
+let noble = null;
+let logger = null;
+const bluetoothState = {
+    available: false,
+    unsupported: false,
+    initialized: false,
+};
+let persistentStateListener = null;
+const discoveredDevices = new Map();
+const connectedDevices = new Map();
+const pairedDevices = new Set();
+const deviceCharacteristics = new Map();
+const notificationCallbacks = new Map();
+const subscribedDevices = new Map();
+const subscriptionOperations = new Map();
+const devicePacketStates = new Map();
+const UKEY_SERVICE_UUIDS = [hardwareShared.UKEY_SERVICE_UUID];
+const NORMALIZED_WRITE_UUID = '0002';
+const NORMALIZED_NOTIFY_UUID = '0003';
+const BLUETOOTH_INIT_TIMEOUT = 10000;
+const DEVICE_SCAN_TIMEOUT = 5000;
+const FAST_SCAN_TIMEOUT = 1500;
+const DEVICE_CHECK_INTERVAL = 500;
+const CONNECTION_TIMEOUT = 3000;
+const BLE_PACKET_SIZE = 192;
+const UNIFIED_WRITE_DELAY = 5;
+const RETRY_CONFIG = { MAX_ATTEMPTS: 15, WRITE_TIMEOUT: 2000 };
+const IS_WINDOWS = process.platform === 'win32';
+const ABORTABLE_WRITE_ERROR_PATTERNS = [
+    /status:\s*3/i,
+];
+const MIN_HEADER_LENGTH = 9;
+function processNotificationData(deviceId, data) {
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification', {
+        deviceId,
+        dataLength: data.length,
+    });
+    let packetState = devicePacketStates.get(deviceId);
+    if (!packetState) {
+        packetState = { bufferLength: 0, buffer: [], packetCount: 0 };
+        devicePacketStates.set(deviceId, packetState);
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Initialized new packet state for device:', deviceId);
+    }
+    try {
+        if (hardwareShared.isHeaderChunk(data)) {
+            if (data.length < MIN_HEADER_LENGTH) {
+                return { isComplete: false, error: 'Invalid header chunk: too short' };
+            }
+            const messageId = `${deviceId}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+            packetState.bufferLength = data.readInt32BE(5);
+            packetState.buffer = [...data.subarray(3)];
+            packetState.packetCount = 1;
+            packetState.messageId = messageId;
+            if (packetState.bufferLength < 0) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Invalid negative packet length detected:', {
+                    length: packetState.bufferLength,
+                    dataLength: data.length,
+                    rawHeader: data.subarray(0, Math.min(16, data.length)).toString('hex'),
+                    lengthBytes: data.subarray(5, 9).toString('hex'),
+                });
+                resetPacketState(packetState);
+                return { isComplete: false, error: 'Invalid packet length in header' };
+            }
+        }
+        else {
+            if (packetState.bufferLength === 0) {
+                return { isComplete: false, error: 'Received data chunk without header' };
+            }
+            packetState.packetCount += 1;
+            packetState.buffer = packetState.buffer.concat([...data]);
+        }
+        if (packetState.buffer.length - hardwareTransport.COMMON_HEADER_SIZE >= packetState.bufferLength) {
+            const completeBuffer = Buffer.from(packetState.buffer);
+            const hexString = completeBuffer.toString('hex');
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Packet assembled', {
+                deviceId,
+                totalPackets: packetState.packetCount,
+                expectedLength: packetState.bufferLength,
+                actualLength: packetState.buffer.length - hardwareTransport.COMMON_HEADER_SIZE,
+            });
+            resetPacketState(packetState);
+            return { isComplete: true, completePacket: hexString };
+        }
+        return { isComplete: false };
+    }
+    catch (error) {
+        resetPacketState(packetState);
+        return { isComplete: false, error: `Packet processing error: ${error}` };
+    }
+}
+function resetPacketState(packetState) {
+    packetState.bufferLength = 0;
+    packetState.buffer = [];
+    packetState.packetCount = 0;
+    packetState.messageId = undefined;
+}
+function checkBluetoothAvailability() {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        if (!bluetoothState.initialized) {
+            yield initializeNoble();
+        }
+        const currentState = (noble === null || noble === void 0 ? void 0 : noble.state) || 'unknown';
+        return {
+            available: bluetoothState.available,
+            state: currentState,
+            unsupported: bluetoothState.unsupported,
+            initialized: bluetoothState.initialized,
+        };
+    });
+}
+function setupPersistentStateListener() {
+    if (!noble || persistentStateListener)
+        return;
+    persistentStateListener = (state) => {
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Persistent state change:', state);
+        updateBluetoothState(state);
+        if (state === 'poweredOff') {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Bluetooth powered off - clearing device caches and resetting state');
+            const connectedIds = Array.from(connectedDevices.keys());
+            for (const deviceId of connectedIds) {
+                try {
+                    cleanupDevice(deviceId, undefined, {
+                        cleanupConnection: true,
+                        sendDisconnectEvent: true,
+                        cancelOperations: true,
+                        reason: 'bluetooth-poweredOff',
+                    });
+                }
+                catch (e) {
+                    safeLog(logger, 'error', 'Failed to cleanup device during poweredOff', {
+                        deviceId,
+                        error: e instanceof Error ? e.message : String(e),
+                    });
+                }
+            }
+            discoveredDevices.clear();
+            deviceCharacteristics.clear();
+            subscribedDevices.clear();
+            notificationCallbacks.clear();
+            devicePacketStates.clear();
+            subscriptionOperations.clear();
+            pairedDevices.clear();
+            if (noble) {
+                try {
+                    noble.stopScanning();
+                }
+                catch (e) {
+                    safeLog(logger, 'error', 'Failed to stop scanning on poweredOff', e instanceof Error ? e.message : String(e));
+                }
+            }
+        }
+    };
+    noble.on('stateChange', persistentStateListener);
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Persistent state listener setup');
+    const currentState = noble.state;
+    if (currentState) {
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Initial state detected:', currentState);
+        updateBluetoothState(currentState);
+    }
+}
+function updateBluetoothState(state) {
+    if (state === 'poweredOn') {
+        bluetoothState.available = true;
+        bluetoothState.unsupported = false;
+        bluetoothState.initialized = true;
+    }
+    else if (state === 'unsupported') {
+        bluetoothState.available = false;
+        bluetoothState.unsupported = true;
+        bluetoothState.initialized = true;
+    }
+    else if (state === 'poweredOff') {
+        bluetoothState.available = false;
+        bluetoothState.unsupported = false;
+        bluetoothState.initialized = true;
+    }
+    else if (state === 'unauthorized') {
+        bluetoothState.available = false;
+        bluetoothState.unsupported = false;
+        bluetoothState.initialized = true;
+    }
+}
+function initializeNoble() {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        if (noble)
+            return;
+        try {
+            noble = require('@stoprocent/noble');
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Noble library loaded');
+            yield new Promise((resolve, reject) => {
+                if (!noble) {
+                    reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'Noble not initialized'));
+                    return;
+                }
+                if (noble.state === 'poweredOn') {
+                    resolve();
+                    return;
+                }
+                setupPersistentStateListener();
+                const timeout = setTimeout(() => {
+                    reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'Bluetooth initialization timeout'));
+                }, BLUETOOTH_INIT_TIMEOUT);
+                const cleanup = () => {
+                    clearTimeout(timeout);
+                    if (noble) {
+                        noble.removeListener('stateChange', onStateChange);
+                    }
+                };
+                const onStateChange = (state) => {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Bluetooth state:', state);
+                    if (state === 'poweredOn') {
+                        cleanup();
+                        resolve();
+                    }
+                    else if (state === 'unsupported') {
+                        cleanup();
+                        reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleUnsupported));
+                    }
+                    else if (state === 'poweredOff') {
+                        cleanup();
+                        reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BlePoweredOff));
+                    }
+                    else if (state === 'unauthorized') {
+                        cleanup();
+                        reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BlePermissionError));
+                    }
+                };
+                noble.on('stateChange', onStateChange);
+            });
+            noble.on('discover', (peripheral) => {
+                handleDeviceDiscovered(peripheral);
+            });
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Noble initialized successfully');
+        }
+        catch (error) {
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to initialize Noble:', error);
+            bluetoothState.unsupported = true;
+            bluetoothState.initialized = true;
+            throw error;
+        }
+    });
+}
+function cleanupDevice(deviceId, webContents, options = {}) {
+    var _a;
+    const { cleanupConnection = true, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', } = options;
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device cleanup', {
+        deviceId,
+        reason,
+        cleanupConnection,
+        sendDisconnectEvent,
+        cancelOperations,
+    });
+    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) {
+        connectedDevices.delete(deviceId);
+        deviceCharacteristics.delete(deviceId);
+        notificationCallbacks.delete(deviceId);
+        devicePacketStates.delete(deviceId);
+        subscribedDevices.delete(deviceId);
+        subscriptionOperations.delete(deviceId);
+        pairedDevices.delete(deviceId);
+    }
+    if (sendDisconnectEvent && webContents) {
+        webContents.send(hardwareShared.EUKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+            id: deviceId,
+            name: deviceName,
+        });
+    }
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device cleanup completed', { deviceId, reason });
+}
+function handleDeviceDisconnect(deviceId, webContents) {
+    var _a;
+    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] ⚠️  DEVICE DISCONNECT DETECTED:', {
+        deviceId,
+        hasPeripheral: connectedDevices.has(deviceId),
+        hasCharacteristics: deviceCharacteristics.has(deviceId),
+        stackTrace: (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split('\n').slice(1, 5),
+    });
+    cleanupDevice(deviceId, webContents, {
+        cleanupConnection: true,
+        sendDisconnectEvent: true,
+        cancelOperations: true,
+        reason: 'auto-disconnect',
+    });
+}
+function setupDisconnectListener(peripheral, deviceId, webContents) {
+    peripheral.removeAllListeners('disconnect');
+    peripheral.on('disconnect', () => {
+        handleDeviceDisconnect(deviceId, webContents);
+    });
+}
+function writeCharacteristicWithAck(deviceId, writeCharacteristic, buffer) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            writeCharacteristic.write(buffer, true, (error) => {
+                if (error) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Write failed', { deviceId, error: String(error) });
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    });
+}
+function attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, payload, contextLabel) {
+    var _a;
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const timeoutMs = RETRY_CONFIG.WRITE_TIMEOUT;
+        for (let attempt = 1; attempt <= RETRY_CONFIG.MAX_ATTEMPTS; attempt++) {
+            if (!connectedDevices.has(deviceId)) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleConnectedError, `Device ${deviceId} disconnected during retry`);
+            }
+            logger === null || logger === void 0 ? void 0 : logger.debug('[BLE-Write] Windows write attempt', {
+                deviceId,
+                attempt,
+                context: contextLabel,
+            });
+            const latestWrite = doGetWriteCharacteristic();
+            if (!latestWrite) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, `Write characteristic not available for ${deviceId}`);
+            }
+            try {
+                yield writeCharacteristicWithAck(deviceId, latestWrite, payload);
+            }
+            catch (e) {
+                const errorMessage = e instanceof Error ? e.message : String(e);
+                logger === null || logger === void 0 ? void 0 : logger.error('[BLE-Write] Windows write error', {
+                    deviceId,
+                    attempt,
+                    context: contextLabel,
+                    error: errorMessage,
+                });
+                if (ABORTABLE_WRITE_ERROR_PATTERNS.some(p => p.test(errorMessage))) {
+                    yield unsubscribeNotifications(deviceId).catch(() => { });
+                    yield disconnectDevice(deviceId).catch(() => { });
+                    discoveredDevices.delete(deviceId);
+                    subscriptionOperations.set(deviceId, 'idle');
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Deep cleanup to reset device state to initial', { deviceId });
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleConnectedError, `Write failed with abortable error for device ${deviceId}: ${errorMessage}`);
+                }
+            }
+            if (pairedDevices.has(deviceId)) {
+                logger === null || logger === void 0 ? void 0 : logger.info('[BLE-Write] Windows write success (paired, exiting loop)', {
+                    deviceId,
+                    attempt,
+                    context: contextLabel,
+                });
+                return;
+            }
+            if (attempt < RETRY_CONFIG.MAX_ATTEMPTS) {
+                yield hardwareShared.wait(timeoutMs);
+            }
+            if (pairedDevices.has(deviceId)) {
+                logger === null || logger === void 0 ? void 0 : logger.info('[BLE-Write] Notification observed during wait (paired), exiting loop', {
+                    deviceId,
+                    attempt,
+                    context: contextLabel,
+                });
+                return;
+            }
+            try {
+                const notifyCharacteristic = (_a = deviceCharacteristics.get(deviceId)) === null || _a === void 0 ? void 0 : _a.notify;
+                yield softRefreshSubscription({
+                    deviceId,
+                    notifyCharacteristic,
+                    subscriptionOperations,
+                    subscribedDevices,
+                    pairedDevices,
+                    notificationCallbacks,
+                    processNotificationData,
+                    logger,
+                });
+                logger === null || logger === void 0 ? void 0 : logger.info('[BLE-Write] Subscription refresh completed', { deviceId });
+            }
+            catch (refreshError) {
+                const errMsg = refreshError instanceof Error ? refreshError.message : String(refreshError);
+                logger === null || logger === void 0 ? void 0 : logger.error('[BLE-Write] Subscription refresh failed', { deviceId, error: errMsg });
+            }
+        }
+        throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.DeviceNotFound, `No response observed after ${RETRY_CONFIG.MAX_ATTEMPTS} writes: ${deviceId}`);
+    });
+}
+function transmitHexDataToDevice(deviceId, hexData) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const characteristics = deviceCharacteristics.get(deviceId);
+        const peripheral = connectedDevices.get(deviceId);
+        if (!peripheral || !characteristics) {
+            throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleCharacteristicNotFound, `Device ${deviceId} not connected or characteristics not available`);
+        }
+        const toBuffer = Buffer.from(hexData, 'hex');
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Writing data:', {
+            deviceId,
+            dataLength: toBuffer.length,
+            firstBytes: toBuffer.subarray(0, 8).toString('hex'),
+        });
+        const doGetWriteCharacteristic = () => { var _a; return (_a = deviceCharacteristics.get(deviceId)) === null || _a === void 0 ? void 0 : _a.write; };
+        if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
+            const writeCharacteristic = doGetWriteCharacteristic();
+            if (!writeCharacteristic) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleCharacteristicNotFound, `Write characteristic not available for ${deviceId}`);
+            }
+            if (toBuffer.length <= BLE_PACKET_SIZE) {
+                yield hardwareShared.wait(UNIFIED_WRITE_DELAY);
+                yield writeCharacteristicWithAck(deviceId, writeCharacteristic, toBuffer);
+                return;
+            }
+            for (let offset = 0, idx = 0; offset < toBuffer.length; idx++) {
+                const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+                const chunk = toBuffer.subarray(offset, offset + chunkSize);
+                offset += chunkSize;
+                const latest = doGetWriteCharacteristic();
+                if (!latest) {
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleCharacteristicNotFound, `Write characteristic not available for ${deviceId}`);
+                }
+                yield writeCharacteristicWithAck(deviceId, latest, chunk);
+                if (offset < toBuffer.length) {
+                    yield hardwareShared.wait(UNIFIED_WRITE_DELAY);
+                }
+            }
+            return;
+        }
+        if (toBuffer.length <= BLE_PACKET_SIZE) {
+            yield hardwareShared.wait(UNIFIED_WRITE_DELAY);
+            yield attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, toBuffer, 'single');
+            return;
+        }
+        for (let offset = 0, idx = 0; offset < toBuffer.length; idx++) {
+            const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+            const chunk = toBuffer.subarray(offset, offset + chunkSize);
+            offset += chunkSize;
+            yield attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, chunk, `chunk-${idx + 1}`);
+            if (offset < toBuffer.length) {
+                yield hardwareShared.wait(UNIFIED_WRITE_DELAY);
+            }
+        }
+    });
+}
+function handleDeviceDiscovered(peripheral) {
+    var _a;
+    const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
+    if (!hardwareShared.isUkeyDevice(deviceName)) {
+        return;
+    }
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered UKey device:', deviceName);
+    discoveredDevices.set(peripheral.id, peripheral);
+}
+function ensureDiscoverListener() {
+    if (!noble)
+        return;
+    const listenerCount = noble.listenerCount('discover');
+    if (listenerCount === 0) {
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discover listener missing, re-adding it');
+        noble.on('discover', (peripheral) => {
+            handleDeviceDiscovered(peripheral);
+        });
+    }
+    else {
+        logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] Discover listener already exists, count:', listenerCount);
+    }
+}
+function performTargetedScan(targetDeviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        if (!noble) {
+            throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'Noble not available');
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting targeted scan for device:', targetDeviceId);
+        ensureDiscoverListener();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (noble) {
+                    noble.stopScanning();
+                }
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
+                resolve(null);
+            }, FAST_SCAN_TIMEOUT);
+            const onDiscover = (peripheral) => {
+                var _a;
+                if (peripheral.id === targetDeviceId) {
+                    clearTimeout(timeout);
+                    if (noble) {
+                        noble.stopScanning();
+                        noble.removeListener('discover', onDiscover);
+                    }
+                    discoveredDevices.set(peripheral.id, peripheral);
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] UKey device found during targeted scan:', {
+                        id: peripheral.id,
+                        name: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown',
+                    });
+                    resolve(peripheral);
+                }
+            };
+            if (noble) {
+                noble.removeListener('discover', onDiscover);
+                noble.on('discover', onDiscover);
+            }
+            if (noble) {
+                noble.startScanning(UKEY_SERVICE_UUIDS, false, (error) => {
+                    if (error) {
+                        clearTimeout(timeout);
+                        if (noble) {
+                            noble.removeListener('discover', onDiscover);
+                        }
+                        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start targeted scan:', error);
+                        reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleScanError, error.message));
+                        return;
+                    }
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan started for device:', targetDeviceId);
+                });
+            }
+        });
+    });
+}
+function enumerateDevices() {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        if (!noble) {
+            yield initializeNoble();
+        }
+        if (!noble) {
+            throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'Noble not available');
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device enumeration');
+        discoveredDevices.clear();
+        ensureDiscoverListener();
+        return new Promise((resolve, reject) => {
+            const devices = [];
+            if (!noble) {
+                reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'Noble not available'));
+                return;
+            }
+            const timeout = setTimeout(() => {
+                if (noble) {
+                    noble.stopScanning();
+                }
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scan completed, found devices:', devices.length);
+                resolve(devices);
+            }, DEVICE_SCAN_TIMEOUT);
+            noble.startScanning(UKEY_SERVICE_UUIDS, false, (error) => {
+                if (error) {
+                    clearTimeout(timeout);
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start scanning:', error);
+                    reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleScanError, error.message));
+                    return;
+                }
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning started for UKey devices');
+                const checkDevices = () => {
+                    discoveredDevices.forEach((peripheral, id) => {
+                        var _a;
+                        const existingDevice = devices.find(d => d.id === id);
+                        if (!existingDevice) {
+                            const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
+                            devices.push({
+                                id,
+                                name: deviceName,
+                                state: peripheral.state || 'disconnected',
+                            });
+                        }
+                    });
+                };
+                const interval = setInterval(checkDevices, DEVICE_CHECK_INTERVAL);
+                setTimeout(() => {
+                    clearInterval(interval);
+                }, DEVICE_SCAN_TIMEOUT);
+            });
+        });
+    });
+}
+function stopScanning() {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        if (!noble)
+            return;
+        return new Promise(resolve => {
+            if (!noble) {
+                resolve();
+                return;
+            }
+            noble.stopScanning(() => {
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning stopped');
+                resolve();
+            });
+        });
+    });
+}
+function cleanupNobleListeners() {
+    if (!noble)
+        return;
+    try {
+        noble.removeAllListeners('discover');
+        noble.removeAllListeners('stateChange');
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] All Noble listeners cleaned up');
+    }
+    catch (error) {
+        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to clean up some listeners:', error);
+    }
+}
+function getDevice(deviceId) {
+    var _a, _b;
+    const peripheral = discoveredDevices.get(deviceId);
+    if (peripheral) {
+        const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
+        return {
+            id: peripheral.id,
+            name: deviceName,
+            state: peripheral.state || 'disconnected',
+        };
+    }
+    const connectedPeripheral = connectedDevices.get(deviceId);
+    if (connectedPeripheral) {
+        const deviceName = ((_b = connectedPeripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName) || 'Unknown Device';
+        return {
+            id: connectedPeripheral.id,
+            name: deviceName,
+            state: connectedPeripheral.state || 'connected',
+        };
+    }
+    return {
+        id: deviceId,
+        name: 'UKey Device',
+        state: 'disconnected',
+    };
+}
+function discoverServicesAndCharacteristics(peripheral) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            peripheral.discoverServices(UKEY_SERVICE_UUIDS, (error, services) => {
+                if (error) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed:', error);
+                    reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleServiceNotFound, error.message));
+                    return;
+                }
+                if (!services || services.length === 0) {
+                    reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleServiceNotFound, 'No UKey services found'));
+                    return;
+                }
+                const service = services[0];
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Found service:', service.uuid);
+                service.discoverCharacteristics([hardwareShared.UKEY_WRITE_CHARACTERISTIC_UUID, hardwareShared.UKEY_NOTIFY_CHARACTERISTIC_UUID], (error, characteristics) => {
+                    if (error) {
+                        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Characteristic discovery failed:', error);
+                        reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleCharacteristicNotFound, error.message));
+                        return;
+                    }
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered characteristics:', {
+                        count: (characteristics === null || characteristics === void 0 ? void 0 : characteristics.length) || 0,
+                        uuids: (characteristics === null || characteristics === void 0 ? void 0 : characteristics.map(c => c.uuid)) || [],
+                    });
+                    let writeCharacteristic = null;
+                    let notifyCharacteristic = null;
+                    for (const characteristic of characteristics) {
+                        const uuid = characteristic.uuid.replace(/-/g, '').toLowerCase();
+                        const uuidKey = uuid.length >= 8 ? uuid.substring(4, 8) : uuid;
+                        if (uuidKey === NORMALIZED_WRITE_UUID) {
+                            writeCharacteristic = characteristic;
+                        }
+                        else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+                            notifyCharacteristic = characteristic;
+                        }
+                    }
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Characteristic discovery result:', {
+                        writeFound: !!writeCharacteristic,
+                        notifyFound: !!notifyCharacteristic,
+                    });
+                    if (!writeCharacteristic || !notifyCharacteristic) {
+                        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Missing characteristics - write:', !!writeCharacteristic, 'notify:', !!notifyCharacteristic);
+                        reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleCharacteristicNotFound, 'Required characteristics not found'));
+                        return;
+                    }
+                    resolve({ write: writeCharacteristic, notify: notifyCharacteristic });
+                });
+            });
+        });
+    });
+}
+function forceReconnectPeripheral(peripheral, deviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Forcing connection reset for device:', deviceId);
+        cleanupDevice(deviceId, undefined, {
+            cleanupConnection: true,
+            sendDisconnectEvent: false,
+            cancelOperations: true,
+            reason: 'force-reconnect',
+        });
+        if (peripheral.state === 'connected') {
+            yield new Promise(resolve => {
+                peripheral.disconnect(() => {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force disconnect completed');
+                    resolve();
+                });
+            });
+            yield hardwareShared.wait(1000);
+        }
+        peripheral.removeAllListeners();
+        yield new Promise((resolve, reject) => {
+            peripheral.connect((error) => {
+                if (error) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Force reconnect failed:', error);
+                    reject(new Error(`Force reconnect failed: ${error.message}`));
+                }
+                else {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force reconnect successful');
+                    connectedDevices.set(deviceId, peripheral);
+                    resolve();
+                }
+            });
+        });
+        yield hardwareShared.wait(500);
+    });
+}
+function connectAndDiscoverWithFreshScan(deviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting connection with fresh peripheral scan as fallback');
+        const currentPeripheral = discoveredDevices.get(deviceId);
+        if (currentPeripheral) {
+            try {
+                return yield discoverServicesAndCharacteristicsWithRetry(currentPeripheral, deviceId);
+            }
+            catch (error) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed with existing peripheral, attempting fresh scan...');
+            }
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Performing fresh scan to get new peripheral object for device:', deviceId);
+        try {
+            const freshPeripheral = yield performTargetedScan(deviceId);
+            if (!freshPeripheral) {
+                discoveredDevices.delete(deviceId);
+                subscriptionOperations.set(deviceId, 'idle');
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Deep cleanup before throwing DeviceNotFound (fresh scan null)', {
+                    deviceId,
+                });
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found in fresh scan`);
+            }
+            discoveredDevices.set(deviceId, freshPeripheral);
+            yield new Promise((resolve, reject) => {
+                freshPeripheral.connect((error) => {
+                    if (error) {
+                        reject(new Error(`Fresh peripheral connection failed: ${error.message}`));
+                    }
+                    else {
+                        connectedDevices.set(deviceId, freshPeripheral);
+                        resolve();
+                    }
+                });
+            });
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting service discovery with fresh peripheral');
+            yield hardwareShared.wait(1000);
+            return yield discoverServicesAndCharacteristics(freshPeripheral);
+        }
+        catch (error) {
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Fresh scan and connection failed:', error);
+            throw error;
+        }
+    });
+}
+function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        return pRetry__default["default"]((attemptNumber) => index.__awaiter(this, void 0, void 0, function* () {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting service discovery:', {
+                deviceId,
+                peripheralState: peripheral.state,
+                attempt: attemptNumber,
+                maxRetries: 5,
+                targetUUIDs: UKEY_SERVICE_UUIDS,
+            });
+            if (attemptNumber === 3) {
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting force reconnect to clear connection state...');
+                try {
+                    yield forceReconnectPeripheral(peripheral, deviceId);
+                }
+                catch (error) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Force reconnect failed:', error);
+                    throw error;
+                }
+            }
+            if (attemptNumber > 1) {
+                logger === null || logger === void 0 ? void 0 : logger.info(`[NobleBLE] Service discovery retry attempt ${attemptNumber}/5`);
+            }
+            if (peripheral.state !== 'connected') {
+                throw new Error(`Device not connected: ${peripheral.state}`);
+            }
+            try {
+                return yield discoverServicesAndCharacteristics(peripheral);
+            }
+            catch (error) {
+                logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] No services found (attempt ${attemptNumber}/5)`);
+                if (attemptNumber < 5) {
+                    logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Will retry service discovery (attempt ${attemptNumber + 1}/5)`);
+                }
+                throw error;
+            }
+        }), {
+            retries: 4,
+            factor: 1.5,
+            minTimeout: 1000,
+            maxTimeout: 3000,
+            onFailedAttempt: error => {
+                logger === null || logger === void 0 ? void 0 : logger.error(`[NobleBLE] Service discovery attempt ${error.attemptNumber} failed:`, {
+                    message: error.message,
+                    retriesLeft: error.retriesLeft,
+                    nextRetryIn: `${Math.min(1000 * Math.pow(1.5, error.attemptNumber), 3000)}ms`,
+                });
+            },
+        });
+    });
+}
+function connectDevice(deviceId, webContents) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
+            deviceId,
+            hasDiscovered: discoveredDevices.has(deviceId),
+            hasConnected: connectedDevices.has(deviceId),
+            hasCharacteristics: deviceCharacteristics.has(deviceId),
+            totalDiscovered: discoveredDevices.size,
+            totalConnected: connectedDevices.size,
+        });
+        let peripheral = discoveredDevices.get(deviceId);
+        if (!peripheral) {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device not discovered, attempting targeted scan for:', deviceId);
+            if (!noble) {
+                yield initializeNoble();
+            }
+            if (!noble) {
+                throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.RuntimeError, 'Noble not available');
+            }
+            try {
+                const foundPeripheral = yield performTargetedScan(deviceId);
+                if (!foundPeripheral) {
+                    throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found even after targeted scan`);
+                }
+                peripheral = foundPeripheral;
+            }
+            catch (error) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Targeted scan failed:', error);
+                throw error;
+            }
+        }
+        if (!peripheral) {
+            throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found`);
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connecting to device:', deviceId);
+        if (peripheral.state === 'connected') {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already connected, skipping connection step');
+            if (!connectedDevices.has(deviceId)) {
+                connectedDevices.set(deviceId, peripheral);
+                setupDisconnectListener(peripheral, deviceId, webContents);
+            }
+            if (deviceCharacteristics.has(deviceId)) {
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device characteristics already available');
+                const ongoingOperation = subscriptionOperations.get(deviceId);
+                if (ongoingOperation && ongoingOperation !== 'idle') {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device has ongoing subscription operation:', ongoingOperation, 'skip reconnect');
+                    return;
+                }
+                const hasActiveSubscription = subscribedDevices.has(deviceId);
+                const hasCallback = notificationCallbacks.has(deviceId);
+                if (hasActiveSubscription && hasCallback) {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already has active notification subscription, reusing connection');
+                    return;
+                }
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Found orphaned characteristics without active subscription, cleaning up');
+                const existingCharacteristics = deviceCharacteristics.get(deviceId);
+                if (existingCharacteristics) {
+                    existingCharacteristics.notify.removeAllListeners('data');
+                }
+                notificationCallbacks.delete(deviceId);
+                devicePacketStates.delete(deviceId);
+                subscribedDevices.delete(deviceId);
+            }
+            yield hardwareShared.wait(300);
+            try {
+                const characteristics = yield connectAndDiscoverWithFreshScan(deviceId);
+                deviceCharacteristics.set(deviceId, characteristics);
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
+                return;
+            }
+            catch (error) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service/characteristic discovery failed after all attempts:', error);
+                throw error;
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleConnectedError, 'Connection timeout'));
+            }, CONNECTION_TIMEOUT);
+            const connectedPeripheral = peripheral;
+            connectedPeripheral.connect((error) => index.__awaiter(this, void 0, void 0, function* () {
+                clearTimeout(timeout);
+                if (error) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection failed:', error);
+                    reject(hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleConnectedError, error.message));
+                    return;
+                }
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connected to device:', deviceId);
+                connectedDevices.set(deviceId, connectedPeripheral);
+                setupDisconnectListener(connectedPeripheral, deviceId, webContents);
+                try {
+                    const characteristics = yield connectAndDiscoverWithFreshScan(deviceId);
+                    deviceCharacteristics.set(deviceId, characteristics);
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
+                    resolve();
+                }
+                catch (discoveryError) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service/characteristic discovery failed after all attempts:', discoveryError);
+                    connectedPeripheral.disconnect();
+                    reject(discoveryError);
+                }
+            }));
+        });
+    });
+}
+function disconnectDevice(deviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const peripheral = connectedDevices.get(deviceId);
+        if (!peripheral) {
+            return;
+        }
+        return new Promise(resolve => {
+            peripheral.removeAllListeners('disconnect');
+            peripheral.disconnect(() => {
+                cleanupDevice(deviceId, undefined, {
+                    cleanupConnection: true,
+                    sendDisconnectEvent: false,
+                    cancelOperations: true,
+                    reason: 'manual-disconnect',
+                });
+                resolve();
+            });
+        });
+    });
+}
+function unsubscribeNotifications(deviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const peripheral = connectedDevices.get(deviceId);
+        const characteristics = deviceCharacteristics.get(deviceId);
+        if (!peripheral || !characteristics) {
+            return;
+        }
+        const { notify: notifyCharacteristic } = characteristics;
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Unsubscribing from notifications for device:', deviceId);
+        subscriptionOperations.set(deviceId, 'unsubscribing');
+        return new Promise(resolve => {
+            notifyCharacteristic.unsubscribe((error) => {
+                if (error) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Notification unsubscription failed:', error);
+                }
+                else {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification unsubscription successful');
+                }
+                notifyCharacteristic.removeAllListeners('data');
+                notificationCallbacks.delete(deviceId);
+                devicePacketStates.delete(deviceId);
+                subscribedDevices.delete(deviceId);
+                subscriptionOperations.set(deviceId, 'idle');
+                resolve();
+            });
+        });
+    });
+}
+function subscribeNotifications(deviceId, callback) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const peripheral = connectedDevices.get(deviceId);
+        const characteristics = deviceCharacteristics.get(deviceId);
+        if (!peripheral || !characteristics) {
+            throw hardwareShared.ERRORS.TypedError(hardwareShared.HardwareErrorCode.BleCharacteristicNotFound, `Device ${deviceId} not connected or characteristics not available`);
+        }
+        const { notify: notifyCharacteristic } = characteristics;
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Subscribing to notifications for device:', deviceId);
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Subscribe context', {
+            deviceId,
+            opStateBefore: subscriptionOperations.get(deviceId) || 'idle',
+            paired: false,
+            hasController: false,
+        });
+        const opState = subscriptionOperations.get(deviceId);
+        if (opState === 'subscribing') {
+            notificationCallbacks.set(deviceId, callback);
+            return Promise.resolve();
+        }
+        subscriptionOperations.set(deviceId, 'subscribing');
+        if (subscribedDevices.get(deviceId)) {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already subscribed to characteristic, updating callback only');
+            notificationCallbacks.set(deviceId, callback);
+            devicePacketStates.set(deviceId, {
+                bufferLength: 0,
+                buffer: [],
+                packetCount: 0,
+                messageId: undefined,
+            });
+            subscriptionOperations.set(deviceId, 'idle');
+            return Promise.resolve();
+        }
+        if (notificationCallbacks.has(deviceId)) {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Cleaning up previous notification listeners');
+        }
+        notifyCharacteristic.removeAllListeners('data');
+        notificationCallbacks.set(deviceId, callback);
+        devicePacketStates.set(deviceId, {
+            bufferLength: 0,
+            buffer: [],
+            packetCount: 0,
+            messageId: undefined,
+        });
+        function rebuildAppSubscription(deviceId, notifyCharacteristic) {
+            return index.__awaiter(this, void 0, void 0, function* () {
+                yield new Promise(resolve => {
+                    notifyCharacteristic.unsubscribe(() => {
+                        resolve();
+                    });
+                });
+                yield new Promise((resolve, reject) => {
+                    notifyCharacteristic.subscribe((error) => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+                notifyCharacteristic.on('data', (data) => {
+                    if (!pairedDevices.has(deviceId)) {
+                        pairedDevices.add(deviceId);
+                        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device paired successfully', { deviceId });
+                    }
+                    const result = processNotificationData(deviceId, data);
+                    if (result.error) {
+                        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Packet processing error:', result.error);
+                        return;
+                    }
+                    if (result.isComplete && result.completePacket) {
+                        const appCb = notificationCallbacks.get(deviceId);
+                        if (appCb)
+                            appCb(result.completePacket);
+                    }
+                });
+            });
+        }
+        yield rebuildAppSubscription(deviceId, notifyCharacteristic);
+        subscribedDevices.set(deviceId, true);
+        subscriptionOperations.set(deviceId, 'idle');
+    });
+}
+function setupNobleBleHandlers(webContents) {
+    console.log('[NobleBLE] Attempting to set up Noble BLE handlers.');
+    try {
+        console.log('[NobleBLE] NOBLE_VERSION_771');
+        logger = require('electron-log');
+        console.log('[NobleBLE] electron-log loaded successfully.');
+        const { ipcMain } = require('electron');
+        console.log('[NobleBLE] electron.ipcMain loaded successfully.');
+        safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
+        console.log(`[NobleBLE] Registering handler for: ${hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_ENUMERATE}`);
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const devices = yield enumerateDevices();
+                safeLog(logger, 'info', 'Enumeration completed, devices:', devices);
+                return devices;
+            }
+            catch (error) {
+                safeLog(logger, 'error', 'Enumeration failed:', error);
+                throw error;
+            }
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, () => index.__awaiter(this, void 0, void 0, function* () {
+            yield stopScanning();
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE, (_event, deviceId) => getDevice(deviceId));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_CONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC CONNECT request received:', {
+                deviceId,
+                hasPeripheral: connectedDevices.has(deviceId),
+                hasCharacteristics: deviceCharacteristics.has(deviceId),
+                totalConnectedDevices: connectedDevices.size,
+            });
+            yield connectDevice(deviceId, webContents);
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_DISCONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+            yield disconnectDevice(deviceId);
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_WRITE, (_event, deviceId, hexData) => index.__awaiter(this, void 0, void 0, function* () {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC WRITE', { deviceId, len: hexData.length });
+            yield transmitHexDataToDevice(deviceId, hexData);
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+            yield subscribeNotifications(deviceId, (data) => {
+                webContents.send(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, deviceId, data);
+            });
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+            yield unsubscribeNotifications(deviceId);
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, () => index.__awaiter(this, void 0, void 0, function* () {
+            const deviceIds = Array.from(connectedDevices.keys());
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Cancel pairing invoked', {
+                platform: process.platform,
+                deviceCount: deviceIds.length,
+            });
+            for (const deviceId of deviceIds) {
+                try {
+                    yield unsubscribeNotifications(deviceId).catch(() => { });
+                    yield disconnectDevice(deviceId).catch(() => { });
+                }
+                catch (e) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Cancel pairing cleanup failed', { deviceId, error: e });
+                }
+            }
+        }));
+        ipcMain.handle(hardwareShared.EUKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, () => index.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const bluetoothStatus = yield checkBluetoothAvailability();
+                safeLog(logger, 'info', 'Bluetooth availability check completed:', bluetoothStatus);
+                return bluetoothStatus;
+            }
+            catch (error) {
+                safeLog(logger, 'error', 'Bluetooth availability check failed:', error);
+                return {
+                    available: false,
+                    state: 'error',
+                    unsupported: false,
+                    initialized: false,
+                };
+            }
+        }));
+        webContents.on('destroyed', () => {
+            safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
+            const deviceIds = Array.from(connectedDevices.keys());
+            deviceIds.forEach(deviceId => {
+                cleanupDevice(deviceId, undefined, {
+                    cleanupConnection: true,
+                    sendDisconnectEvent: false,
+                    cancelOperations: true,
+                    reason: 'app-quit',
+                });
+            });
+            stopScanning();
+            if (noble && persistentStateListener) {
+                noble.removeListener('stateChange', persistentStateListener);
+                persistentStateListener = null;
+            }
+            cleanupNobleListeners();
+            discoveredDevices.clear();
+            safeLog(logger, 'info', 'Noble BLE cleanup completed');
+        });
+        safeLog(logger, 'info', 'Noble BLE IPC handlers setup completed');
+    }
+    catch (error) {
+        console.error('[NobleBLE] Failed to setup IPC handlers:', error);
+        throw error;
+    }
+}
+
+exports.setupNobleBleHandlers = setupNobleBleHandlers;