@onekeyfe/hd-transport-react-native 1.2.0-alpha.1 → 1.2.0-alpha.100

package/dist/index.js

@@ -93,7 +93,8 @@ const onDeviceBondState = (bleMacAddress) => new Promise((resolve, reject) => {
 
 const IOS_PACKET_LENGTH = 128;
 const ANDROID_PACKET_LENGTH = 192;
-const ANDROID_DEFAULT_MTU = 23;
+const IOS_PROTOCOL_V2_PACKET_LENGTH = 244;
+const ANDROID_PROTOCOL_V2_PACKET_LENGTH = 244;
 const ClassicServiceUUID = '00000001-0000-1000-8000-00805f9b34fb';
 const OneKeyServices = {
     classic: {
@@ -117,51 +118,38 @@ const getInfosForServiceUuid = (serviceUuid, deviceType) => {
         return null;
     }
     const normalizedServiceUuid = normalizeBleUuid(serviceUuid);
-    const service = (_a = services[serviceUuid]) !== null && _a !== void 0 ? _a : Object.values(services).find(item => normalizeBleUuid(item.serviceUuid) === normalizedServiceUuid);
+    const service = (_a = services[serviceUuid]) !== null && _a !== void 0 ? _a : Object.values(services).find(item => normalizeBleUuid(item.serviceUuid) === normalizedServiceUuid ||
+        hdShared.matchesKnownBleUuid(serviceUuid, hdShared.createKnownBleUuidAliases(item.serviceUuid)));
     if (!service) {
         return null;
     }
     return service;
 };
 const normalizeBleUuid = (uuid) => (uuid !== null && uuid !== void 0 ? uuid : '').replace(/-/g, '').toLowerCase();
-const getBleUuidKey = (uuid) => {
-    const normalized = normalizeBleUuid(uuid);
-    return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
-};
 const isSameBleUuid = (left, right) => {
-    const normalizedLeft = normalizeBleUuid(left);
-    const normalizedRight = normalizeBleUuid(right);
-    return (normalizedLeft === normalizedRight ||
-        (getBleUuidKey(left) !== '' && getBleUuidKey(left) === getBleUuidKey(right)));
+    if (!left || !right)
+        return false;
+    return hdShared.matchesKnownBleUuid(left, hdShared.createKnownBleUuidAliases(right));
 };
 
 function hasWritableCapability(characteristic) {
     return !!(characteristic.isWritableWithResponse || characteristic.isWritableWithoutResponse);
 }
-function resolveBleWriteMode(characteristic, preferredMode = 'withoutResponse') {
-    if (preferredMode === 'withoutResponse' && characteristic.isWritableWithoutResponse) {
-        return 'withoutResponse';
-    }
-    if (preferredMode === 'withResponse' && characteristic.isWritableWithResponse) {
-        return 'withResponse';
-    }
-    if (characteristic.isWritableWithoutResponse) {
-        return 'withoutResponse';
-    }
-    if (characteristic.isWritableWithResponse) {
-        return 'withResponse';
-    }
-    return preferredMode;
+function resolveProtocolV2PacketCapacity({ platform, iosPacketLength = IOS_PROTOCOL_V2_PACKET_LENGTH, androidPacketLength = ANDROID_PROTOCOL_V2_PACKET_LENGTH, mtu, }) {
+    const negotiatedMtu = typeof mtu === 'number' && Number.isFinite(mtu) && mtu > 3 ? Math.floor(mtu) : 23;
+    const payloadLength = negotiatedMtu - 3;
+    const configuredPacketLength = platform === 'ios' ? iosPacketLength : androidPacketLength;
+    return Math.min(configuredPacketLength, payloadLength);
 }
-function resolveProtocolV2PacketCapacity({ platform, iosPacketLength = IOS_PACKET_LENGTH, androidPacketLength = ANDROID_PACKET_LENGTH, mtu, }) {
-    if (platform === 'ios') {
-        return iosPacketLength;
-    }
-    if (platform === 'android') {
-        const payloadLength = Math.max((mtu !== null && mtu !== void 0 ? mtu : ANDROID_DEFAULT_MTU) - 3, 1);
-        return Math.min(androidPacketLength, payloadLength);
-    }
-    return androidPacketLength;
+function shouldRefreshNegotiatedMtu(mtu) {
+    return typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= 23;
+}
+function shouldWriteProtocolV2WithResponse({ platform, highThroughput, requestedWithResponse, characteristic, }) {
+    if (!characteristic.isWritableWithResponse)
+        return false;
+    if (!characteristic.isWritableWithoutResponse)
+        return true;
+    return requestedWithResponse === true || (platform === 'ios' && !highThroughput);
 }
 
 const timer = process.env.NODE_ENV === 'development'
@@ -189,7 +177,6 @@ const timer = process.env.NODE_ENV === 'development'
 const subscribeBleOn = (bleManager, ms = 1000) => new Promise((resolve, reject) => {
     let done = false;
     const subscription = bleManager.onStateChange(state => {
-        console.log('ble state -> ', state);
         if (state === 'PoweredOn') {
             if (done)
                 return;
@@ -219,47 +206,20 @@ const isHeaderChunk = (chunk) => {
     return false;
 };
 
-const Log$1 = bleLogger;
 class BleTransport {
     constructor(device, writeCharacteristic, notifyCharacteristic) {
         this.name = 'ReactNativeBleTransport';
-        this.mtuSize = 23;
         this.id = device.id;
         this.device = device;
         this.writeCharacteristic = writeCharacteristic;
         this.notifyCharacteristic = notifyCharacteristic;
     }
-    writeWithRetry(data, retryCount = BleTransport.MAX_RETRIES) {
+    writeWithRetry(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.writeCharacteristic.writeWithoutResponse(data);
-            }
-            catch (error) {
-                Log$1 === null || Log$1 === void 0 ? void 0 : Log$1.debug(`Write retry attempt ${BleTransport.MAX_RETRIES - retryCount + 1}, error: ${error}`);
-                if (retryCount > 0) {
-                    yield hdShared.wait(BleTransport.RETRY_DELAY);
-                    if (error.errorCode === reactNativeBlePlx.BleErrorCode.DeviceDisconnected ||
-                        error.errorCode === reactNativeBlePlx.BleErrorCode.CharacteristicNotFound) {
-                        try {
-                            yield this.device.connect();
-                            yield this.device.discoverAllServicesAndCharacteristics();
-                        }
-                        catch (e) {
-                            Log$1 === null || Log$1 === void 0 ? void 0 : Log$1.debug(`Connect or discoverAllServicesAndCharacteristics error: ${e}`);
-                        }
-                    }
-                    else {
-                        Log$1 === null || Log$1 === void 0 ? void 0 : Log$1.debug(`writeCharacteristic error: ${error}`);
-                    }
-                    return this.writeWithRetry(data, retryCount - 1);
-                }
-                throw error;
-            }
+            yield this.writeCharacteristic.writeWithoutResponse(data);
         });
     }
 }
-BleTransport.MAX_RETRIES = 5;
-BleTransport.RETRY_DELAY = 2000;
 
 const { check, ProtocolV1, parseConfigure } = transport__default["default"];
 const Log = bleLogger;
@@ -268,10 +228,35 @@ const FIRMWARE_UPLOAD_WRITE_BURST_SIZE = reactNative.Platform.OS === 'ios' ? 4 :
 const FIRMWARE_UPLOAD_WRITE_PAUSE_MS = reactNative.Platform.OS === 'ios' ? 8 : 10;
 const FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS = reactNative.Platform.OS === 'ios' ? 24 : 30;
 const FIRMWARE_UPLOAD_WRITE_MAX_RETRIES = 8;
-const FIRMWARE_UPLOAD_RECONNECT_RETRY_DELAY_MS = 2000;
 const ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH = 192;
 const FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY = reactNative.Platform.OS === 'ios' ? IOS_PACKET_LENGTH : ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH;
 const ANDROID_GATT_CONGESTED_STATUS = 143;
+const isAsciiWhitespace = (code) => code === 0x09 ||
+    code === 0x0a ||
+    code === 0x0b ||
+    code === 0x0c ||
+    code === 0x0d ||
+    code === 0x20;
+const hasGattCongestedStatus = (text) => {
+    let searchFrom = 0;
+    while (searchFrom < text.length) {
+        const statusIndex = text.indexOf('status', searchFrom);
+        if (statusIndex < 0)
+            return false;
+        let cursor = statusIndex + 'status'.length;
+        while (cursor < text.length && isAsciiWhitespace(text.charCodeAt(cursor)))
+            cursor += 1;
+        if (text[cursor] === ':' || text[cursor] === '=') {
+            cursor += 1;
+            while (cursor < text.length && isAsciiWhitespace(text.charCodeAt(cursor)))
+                cursor += 1;
+        }
+        if (text.startsWith(String(ANDROID_GATT_CONGESTED_STATUS), cursor))
+            return true;
+        searchFrom = statusIndex + 'status'.length;
+    }
+    return false;
+};
 const delay = (ms) => new Promise(resolve => {
     setTimeout(resolve, ms);
 });
@@ -279,10 +264,6 @@ const getFirmwareUploadWriteRetryType = (error) => {
     if (!error || typeof error !== 'object')
         return null;
     const bleWriteError = error;
-    if (bleWriteError.errorCode === reactNativeBlePlx.BleErrorCode.DeviceDisconnected ||
-        bleWriteError.errorCode === reactNativeBlePlx.BleErrorCode.CharacteristicNotFound) {
-        return 'reconnectable';
-    }
     if (bleWriteError.androidErrorCode === ANDROID_GATT_CONGESTED_STATUS ||
         bleWriteError.status === ANDROID_GATT_CONGESTED_STATUS) {
         return 'congested';
@@ -290,25 +271,23 @@ const getFirmwareUploadWriteRetryType = (error) => {
     const text = [bleWriteError.reason, bleWriteError.message, bleWriteError.name]
         .filter(value => typeof value === 'string')
         .join(' ');
-    return /GATT_CONGESTED|status\s*[:=]?\s*143/.test(text) ? 'congested' : null;
+    return text.includes('GATT_CONGESTED') || hasGattCongestedStatus(text) ? 'congested' : null;
 };
 const resolveFirmwareUploadRetryDelay = (attempt, baseDelayMs = 200, maxDelayMs = 1200) => Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
-const BLE_RESPONSE_TIMEOUT_MS = 30000;
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 10000;
-const DEVICE_SCAN_TIMEOUT_MS = 8000;
+const BLE_WRITE_PACKET_TIMEOUT_MS = 10000;
+const WEDGED_WRITE_MESSAGE = 'BLE write timeout after';
+const isWedgedWriteError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleWriteCharacteristicError &&
+    typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' &&
+    error.message.startsWith(WEDGED_WRITE_MESSAGE);
+const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
+const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
 const ANDROID_NOTIFY_READY_DELAY_MS = 300;
-const HIGH_VOLUME_WRITE_BURST_SIZE = reactNative.Platform.OS === 'ios' ? 4 : 6;
-const HIGH_VOLUME_WRITE_PAUSE_MS = reactNative.Platform.OS === 'ios' ? 6 : 2;
-const HIGH_VOLUME_WRITE_FLUSH_DELAY_MS = reactNative.Platform.OS === 'ios' ? 20 : 8;
 const DEFAULT_PROTOCOL_V2_BLE_TUNING = {
-    iosPacketLength: IOS_PACKET_LENGTH,
-    androidPacketLength: ANDROID_PACKET_LENGTH,
-    highVolumeWriteBurstSize: HIGH_VOLUME_WRITE_BURST_SIZE,
-    highVolumeWritePauseMs: HIGH_VOLUME_WRITE_PAUSE_MS,
-    highVolumeWriteFlushDelayMs: HIGH_VOLUME_WRITE_FLUSH_DELAY_MS,
-    highVolumeWriteWithResponse: false,
+    iosPacketLength: IOS_PROTOCOL_V2_PACKET_LENGTH,
+    androidPacketLength: ANDROID_PROTOCOL_V2_PACKET_LENGTH,
 };
 let protocolV2BleTuning = Object.assign({}, DEFAULT_PROTOCOL_V2_BLE_TUNING);
 const normalizePositiveInteger = (value, fallback) => {
@@ -318,20 +297,15 @@ const normalizePositiveInteger = (value, fallback) => {
     return Math.floor(normalized);
 };
 function configureProtocolV2BleTuning(tuning = {}) {
-    var _a;
     protocolV2BleTuning = {
         iosPacketLength: normalizePositiveInteger(tuning.iosPacketLength, protocolV2BleTuning.iosPacketLength),
         androidPacketLength: normalizePositiveInteger(tuning.androidPacketLength, protocolV2BleTuning.androidPacketLength),
-        highVolumeWriteBurstSize: normalizePositiveInteger(tuning.highVolumeWriteBurstSize, protocolV2BleTuning.highVolumeWriteBurstSize),
-        highVolumeWritePauseMs: normalizePositiveInteger(tuning.highVolumeWritePauseMs, protocolV2BleTuning.highVolumeWritePauseMs),
-        highVolumeWriteFlushDelayMs: normalizePositiveInteger(tuning.highVolumeWriteFlushDelayMs, protocolV2BleTuning.highVolumeWriteFlushDelayMs),
-        highVolumeWriteWithResponse: (_a = tuning.highVolumeWriteWithResponse) !== null && _a !== void 0 ? _a : protocolV2BleTuning.highVolumeWriteWithResponse,
     };
-    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 BLE tuning configured:', protocolV2BleTuning);
+    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE tuning configured', protocolV2BleTuning);
 }
 function resetProtocolV2BleTuning() {
     protocolV2BleTuning = Object.assign({}, DEFAULT_PROTOCOL_V2_BLE_TUNING);
-    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 BLE tuning reset:', protocolV2BleTuning);
+    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE tuning reset', protocolV2BleTuning);
 }
 function getProtocolV2BleTuning() {
     return Object.assign({}, protocolV2BleTuning);
@@ -342,19 +316,29 @@ function inferProtocolHintFromDeviceName(name) {
 function getDeviceDisplayName(device) {
     return (device === null || device === void 0 ? void 0 : device.name) || (device === null || device === void 0 ? void 0 : device.localName) || null;
 }
-function isGenericBleService(uuid) {
-    return ['1800', '1801', '180a'].includes(getBleUuidKey(uuid));
-}
-function hasKnownOneKeyService(device) {
-    var _a;
-    return ((_a = device === null || device === void 0 ? void 0 : device.serviceUUIDs) !== null && _a !== void 0 ? _a : []).some(serviceUuid => getInfosForServiceUuid(serviceUuid, 'classic'));
-}
-const ANDROID_REQUEST_MTU = 256;
+const IOS_REQUEST_MTU = 247;
+const ANDROID_REQUEST_MTU = 517;
+const BLE_MTU_REFRESH_RETRY_DELAY_MS = 200;
+const ANDROID_HIGH_PRIORITY_IDLE_MS = 1000;
+const getRequestedBleMtu = () => reactNative.Platform.OS === 'android' ? ANDROID_REQUEST_MTU : IOS_REQUEST_MTU;
+const BLE_NATIVE_CONNECT_TIMEOUT_MS = 3000;
 const connectOptions = {
-    requestMTU: ANDROID_REQUEST_MTU,
-    timeout: 3000,
+    requestMTU: getRequestedBleMtu(),
+    timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
     refreshGatt: 'OnConnected',
 };
+const fallbackConnectOptions = {
+    timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
+};
+const BLE_CONNECT_TIMEOUT_MS = BLE_NATIVE_CONNECT_TIMEOUT_MS * 2 + 2000;
+const BLE_GATT_SETUP_TIMEOUT_MS = 10000;
+const PROTOCOL_REPROBE_FALLBACK_ATTEMPTS = 3;
+const BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
+const CONNECT_TIMEOUT_MESSAGE = 'BLE connect timeout after';
+const isConnectTimeoutError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleConnectedError &&
+    typeof (error === null || error === void 0 ? void 0 : error.message) === 'string' &&
+    error.message.startsWith(CONNECT_TIMEOUT_MESSAGE);
+const isNativeOperationTimeoutError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === reactNativeBlePlx.BleErrorCode.OperationTimedOut;
 const tryToGetConfiguration = (device) => {
     if (!device || !device.serviceUUIDs)
         return null;
@@ -366,22 +350,25 @@ const tryToGetConfiguration = (device) => {
         return null;
     return infos;
 };
-const requestAndroidMtu = (device) => __awaiter(void 0, void 0, void 0, function* () {
-    if (reactNative.Platform.OS !== 'android')
+const requestNegotiatedMtu = (device, stage, attempt) => __awaiter(void 0, void 0, void 0, function* () {
+    if (reactNative.Platform.OS !== 'ios' && reactNative.Platform.OS !== 'android')
         return device;
     try {
-        const mtuDevice = yield device.requestMTU(ANDROID_REQUEST_MTU);
-        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android MTU requested:', {
-            requested: ANDROID_REQUEST_MTU,
-            mtu: mtuDevice.mtu,
-        });
+        const mtuDevice = yield device.requestMTU(getRequestedBleMtu());
         return mtuDevice;
     }
     catch (error) {
-        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android MTU request failed:', error);
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] MTU refresh failed, continuing with current value', {
+            platform: reactNative.Platform.OS,
+            stage,
+            attempt,
+            actual: device.mtu,
+            error: error instanceof Error ? error.message : String(error),
+        });
         return device;
     }
 });
+const resolveNegotiatedMtu = (device) => requestNegotiatedMtu(device, 'connected', 0);
 function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
@@ -408,15 +395,44 @@ class ReactNativeBleTransport {
         this.stopped = false;
         this.scanTimeout = DEVICE_SCAN_TIMEOUT_MS;
         this.runPromise = null;
+        this.runPromiseDeviceId = null;
         this.firmwareUploadWriteRecoveryIds = new Set();
         this.deviceProtocol = new Map();
+        this.probingProtocols = new Map();
+        this.writeTimeoutCounts = new Map();
+        this.connectionSetupTimeoutCounts = new Map();
         this.deviceProtocolHints = new Map();
+        this.sessionProtocols = new Map();
+        this.protocolReprobeFailures = new Map();
         this.protocolV2Assemblers = new Map();
         this.protocolV2FrameQueues = new Map();
         this.protocolV2FramePromises = new Map();
-        this.activeProtocolV2Call = null;
-        this.nextProtocolV2CallToken = 1;
+        this.protocolV2Links = new transport.ProtocolV2LinkManager({
+            getSchemas: () => {
+                if (!this._messages || !this._messagesV2) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+                }
+                return {
+                    protocolV1: this._messages,
+                    protocolV2: this._messagesV2,
+                };
+            },
+            classifyError: () => 'link-fatal',
+            onLinkInvalidated: (uuid, reason) => __awaiter(this, void 0, void 0, function* () {
+                var _b;
+                (_b = this.protocolV2Assemblers.get(uuid)) === null || _b === void 0 ? void 0 : _b.reset();
+                this.rejectProtocolV2Frames(uuid, new Error(reason));
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 link invalidated:', uuid, reason);
+                if (reason.startsWith('Protocol V2 link-fatal error:')) {
+                    yield this.releaseNative(uuid, true);
+                }
+            }),
+        });
         this.monitorTokens = new Map();
+        this.disconnectEventTokens = new Map();
+        this.protocolV2HighVolumeLogSignatures = new Map();
+        this.androidHighPriorityDevices = new Set();
+        this.androidPriorityResetTimers = new Map();
         this.nextMonitorToken = 1;
         this.scanTimeout = (_a = options.scanTimeout) !== null && _a !== void 0 ? _a : DEVICE_SCAN_TIMEOUT_MS;
     }
@@ -430,8 +446,18 @@ class ReactNativeBleTransport {
         this._messages = messages;
     }
     configureProtocolV2(signedData) {
+        const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+        if (this.protocolV2SchemaConfiguration === configuration) {
+            return;
+        }
+        const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
         this._messagesV2 = parseConfigure(signedData);
-        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 schema configured');
+        this.protocolV2SchemaConfiguration = configuration;
+        if (isReconfiguration) {
+            this.protocolV2Links
+                .invalidateAllLinks('Protocol V2 schema reconfigured')
+                .catch(error => Log === null || Log === void 0 ? void 0 : Log.debug('Protocol V2 schema link cleanup failed:', error));
+        }
     }
     listen() {
     }
@@ -442,7 +468,6 @@ class ReactNativeBleTransport {
         return Promise.resolve(this.blePlxManager);
     }
     resolveCharacteristics(device) {
-        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             yield device.discoverAllServicesAndCharacteristics();
             let infos = tryToGetConfiguration(device);
@@ -459,19 +484,11 @@ class ReactNativeBleTransport {
                     }
                 }
             }
-            let fallbackServiceUuid;
             if (!infos) {
                 const services = yield device.services();
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Known OneKey service UUID not found, discovered services:', services === null || services === void 0 ? void 0 : services.map(service => service.uuid));
-                const knownService = services.find(service => getInfosForServiceUuid(service.uuid, 'classic'));
-                const fallbackService = (_a = knownService !== null && knownService !== void 0 ? knownService : services.find(service => !isGenericBleService(service.uuid))) !== null && _a !== void 0 ? _a : services[0];
-                if (fallbackService) {
-                    fallbackServiceUuid = fallbackService.uuid;
-                    characteristics = yield device.characteristicsForService(fallbackService.uuid);
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Using fallback BLE service:', fallbackService.uuid);
-                }
             }
-            if (!infos && !fallbackServiceUuid) {
+            if (!infos) {
                 try {
                     Log === null || Log === void 0 ? void 0 : Log.debug('cancel connection when service not found');
                     yield device.cancelConnection();
@@ -481,9 +498,7 @@ class ReactNativeBleTransport {
                 }
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
             }
-            const serviceUuid = (_b = infos === null || infos === void 0 ? void 0 : infos.serviceUuid) !== null && _b !== void 0 ? _b : fallbackServiceUuid;
-            const writeUuid = (_c = infos === null || infos === void 0 ? void 0 : infos.writeUuid) !== null && _c !== void 0 ? _c : '00000002-0000-1000-8000-00805f9b34fb';
-            const notifyUuid = (_d = infos === null || infos === void 0 ? void 0 : infos.notifyUuid) !== null && _d !== void 0 ? _d : '00000003-0000-1000-8000-00805f9b34fb';
+            const { serviceUuid, writeUuid, notifyUuid } = infos;
             if (!serviceUuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
             }
@@ -524,8 +539,8 @@ class ReactNativeBleTransport {
     attachDisconnectSubscription(transport, device, uuid) {
         var _a;
         (_a = transport.disconnectSubscription) === null || _a === void 0 ? void 0 : _a.remove();
+        const { monitorToken } = transport;
         transport.disconnectSubscription = device.onDisconnected(() => {
-            var _a;
             if (this.firmwareUploadWriteRecoveryIds.has(uuid)) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('device disconnect ignored during FirmwareUpload write recovery: ', uuid);
                 return;
@@ -534,17 +549,16 @@ class ReactNativeBleTransport {
                 Log === null || Log === void 0 ? void 0 : Log.debug('device disconnect ignored for stale transport: ', device === null || device === void 0 ? void 0 : device.id);
                 return;
             }
+            if (this.monitorTokens.get(uuid) !== monitorToken) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('device disconnect ignored for stale generation: ', device === null || device === void 0 ? void 0 : device.id);
+                return;
+            }
             try {
                 Log === null || Log === void 0 ? void 0 : Log.debug('device disconnect: ', device === null || device === void 0 ? void 0 : device.id);
-                (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit('device-disconnect', {
-                    name: device === null || device === void 0 ? void 0 : device.name,
-                    id: device === null || device === void 0 ? void 0 : device.id,
-                    connectId: device === null || device === void 0 ? void 0 : device.id,
-                });
-                if (this.runPromise) {
+                this.emitDeviceDisconnect(uuid, device === null || device === void 0 ? void 0 : device.name, monitorToken);
+                if (this.runPromise && this.runPromiseDeviceId === uuid) {
                     const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError);
                     this.runPromise.reject(error);
-                    this.rejectAllProtocolV2Frames(error);
                 }
             }
             catch (e) {
@@ -555,6 +569,22 @@ class ReactNativeBleTransport {
             }
         });
     }
+    emitDeviceDisconnect(uuid, name, token) {
+        var _a;
+        if (token === undefined || this.disconnectEventTokens.get(uuid) === token) {
+            return;
+        }
+        if (this.monitorTokens.get(uuid) !== token) {
+            Log === null || Log === void 0 ? void 0 : Log.debug('device disconnect event ignored for stale generation: ', uuid);
+            return;
+        }
+        this.disconnectEventTokens.set(uuid, token);
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit(transport.TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+            name,
+            id: uuid,
+            connectId: uuid,
+        });
+    }
     reconnectFirmwareUploadTransport(uuid, transport) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -568,19 +598,19 @@ class ReactNativeBleTransport {
                 const isConnected = yield device.isConnected().catch(() => false);
                 if (!isConnected) {
                     try {
-                        device = yield device.connect(connectOptions);
+                        device = yield this.connectWithTimeout(uuid, () => device.connect(connectOptions));
                     }
                     catch (e) {
                         if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
                             e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
-                            device = yield device.connect();
+                            device = yield this.connectWithTimeout(uuid, () => device.connect());
                         }
                         else if (e.errorCode !== reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
                             throw e;
                         }
                     }
                 }
-                const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristics(device);
+                const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, device);
                 transport.device = device;
                 transport.writeCharacteristic = writeCharacteristic;
                 transport.notifyCharacteristic = notifyCharacteristic;
@@ -624,13 +654,12 @@ class ReactNativeBleTransport {
                         return;
                     }
                 }
-                blePlxManager.startDeviceScan(null, {
+                blePlxManager.startDeviceScan(getBluetoothServiceUuids(), {
                     allowDuplicates: true,
                     scanMode: reactNativeBlePlx.ScanMode.LowLatency,
                 }, (error, device) => {
-                    var _a, _b, _c;
+                    var _a;
                     if (error) {
-                        Log === null || Log === void 0 ? void 0 : Log.debug('ble scan manager: ', blePlxManager);
                         Log === null || Log === void 0 ? void 0 : Log.debug('ble scan error: ', error);
                         if ([reactNativeBlePlx.BleErrorCode.BluetoothPoweredOff, reactNativeBlePlx.BleErrorCode.BluetoothInUnknownState].includes(error.errorCode)) {
                             reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError));
@@ -650,25 +679,19 @@ class ReactNativeBleTransport {
                         return;
                     }
                     const displayName = getDeviceDisplayName(device);
-                    const isOneKey = hdShared.isOnekeyDevice((_b = device === null || device === void 0 ? void 0 : device.name) !== null && _b !== void 0 ? _b : null, device === null || device === void 0 ? void 0 : device.id) ||
-                        hdShared.isOnekeyDevice((_c = device === null || device === void 0 ? void 0 : device.localName) !== null && _c !== void 0 ? _c : null, device === null || device === void 0 ? void 0 : device.id) ||
-                        hasKnownOneKeyService(device);
-                    const shouldTraceCandidate = !!displayName && /onekey|bixinkey|pro\s*2|pro\b|touch|^k\d|^t\d/i.test(displayName);
-                    if (shouldTraceCandidate) {
-                        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] scan candidate', {
+                    const isUnnamedIOSPeripheral = reactNative.Platform.OS === 'ios' && !(displayName === null || displayName === void 0 ? void 0 : displayName.trim());
+                    const isFindMyPeripheral = hdShared.isPro2FindMyAdvertisementName(device === null || device === void 0 ? void 0 : device.name) ||
+                        hdShared.isPro2FindMyAdvertisementName(device === null || device === void 0 ? void 0 : device.localName);
+                    const isOneKey = !isUnnamedIOSPeripheral &&
+                        !isFindMyPeripheral &&
+                        hdShared.isOnekeyBluetoothDevice({
+                            id: device === null || device === void 0 ? void 0 : device.id,
                             name: device === null || device === void 0 ? void 0 : device.name,
                             localName: device === null || device === void 0 ? void 0 : device.localName,
-                            id: device === null || device === void 0 ? void 0 : device.id,
-                            serviceUUIDs: device === null || device === void 0 ? void 0 : device.serviceUUIDs,
-                            accepted: isOneKey,
+                            serviceUuids: device === null || device === void 0 ? void 0 : device.serviceUUIDs,
                         });
-                    }
                     if (isOneKey) {
-                        Log === null || Log === void 0 ? void 0 : Log.debug('search device start ======================');
-                        const { name, localName, id, serviceUUIDs } = device !== null && device !== void 0 ? device : {};
-                        Log === null || Log === void 0 ? void 0 : Log.debug(`device name: ${name !== null && name !== void 0 ? name : ''}\nlocalName: ${localName !== null && localName !== void 0 ? localName : ''}\nid: ${id !== null && id !== void 0 ? id : ''}\nserviceUUIDs: ${(serviceUUIDs !== null && serviceUUIDs !== void 0 ? serviceUUIDs : []).join(',')}`);
                         addDevice(device);
-                        Log === null || Log === void 0 ? void 0 : Log.debug('search device end ======================\n');
                     }
                     else if (displayName && /\bpro\s*2\b/i.test(displayName)) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Pro2-like BLE device was not accepted:', {
@@ -679,10 +702,23 @@ class ReactNativeBleTransport {
                         });
                     }
                 });
-                getConnectedDeviceIds(getBluetoothServiceUuids()).then(devices => {
+                getConnectedDeviceIds(reactNative.Platform.OS === 'ios' ? getBluetoothServiceUuids() : []).then(devices => {
                     for (const device of devices) {
-                        Log === null || Log === void 0 ? void 0 : Log.debug('search connected peripheral: ', device.id);
-                        addDevice(device);
+                        const localName = 'localName' in device && typeof device.localName === 'string'
+                            ? device.localName
+                            : null;
+                        const isFindMyPeripheral = hdShared.isPro2FindMyAdvertisementName(device.name) ||
+                            hdShared.isPro2FindMyAdvertisementName(localName);
+                        if (!isFindMyPeripheral &&
+                            hdShared.isOnekeyBluetoothDevice({
+                                id: device.id,
+                                name: device.name,
+                                localName,
+                                serviceUuids: device.serviceUUIDs,
+                            })) {
+                            Log === null || Log === void 0 ? void 0 : Log.debug('search connected peripheral: ', device.id);
+                            addDevice(device);
+                        }
                     }
                 });
                 const addDevice = (device) => {
@@ -694,6 +730,12 @@ class ReactNativeBleTransport {
                             this.deviceProtocolHints.set(device.id, protocolHint);
                         }
                         deviceList.push(Object.assign(Object.assign({}, device), { name: displayName, commType: 'ble' }));
+                        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] OneKey BLE device discovered', {
+                            deviceId: device.id,
+                            name: displayName,
+                            serviceUUIDs: device.serviceUUIDs,
+                            protocolHint,
+                        });
                     }
                 };
                 timer.timeout(() => {
@@ -703,6 +745,57 @@ class ReactNativeBleTransport {
             }));
         });
     }
+    installTransportForAcquire(uuid, device, characteristics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { writeCharacteristic, notifyCharacteristic } = characteristics !== null && characteristics !== void 0 ? characteristics : (yield this.resolveCharacteristicsWithTimeout(uuid, device));
+            const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
+            transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : undefined;
+            const monitorToken = this.nextMonitorToken;
+            this.nextMonitorToken += 1;
+            const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
+            transport$1.monitorToken = monitorToken;
+            transport$1.notifyTransactionId = notifyTransactionId;
+            this.monitorTokens.set(uuid, monitorToken);
+            transport$1.notifySubscription = this._monitorCharacteristic(transport$1.notifyCharacteristic, uuid, monitorToken, notifyTransactionId);
+            transportCache[uuid] = transport$1;
+            this.protocolV2HighVolumeLogSignatures.set(uuid, new Set());
+            this.protocolV2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
+            if (reactNative.Platform.OS === 'ios') {
+                yield new Promise(resolve => {
+                    setTimeout(resolve, IOS_NOTIFY_READY_DELAY_MS);
+                });
+            }
+            else if (reactNative.Platform.OS === 'android') {
+                yield delay(ANDROID_NOTIFY_READY_DELAY_MS);
+            }
+            const initialMtu = transport$1.mtuSize;
+            let refreshAttempts = 0;
+            if ((reactNative.Platform.OS === 'ios' || reactNative.Platform.OS === 'android') &&
+                shouldRefreshNegotiatedMtu(transport$1.mtuSize)) {
+                refreshAttempts += 1;
+                let refreshedDevice = yield requestNegotiatedMtu(transport$1.device, 'servicesAndNotifyReady', 1);
+                transport$1.device = refreshedDevice;
+                transport$1.mtuSize =
+                    typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport$1.mtuSize;
+                if (shouldRefreshNegotiatedMtu(transport$1.mtuSize)) {
+                    yield delay(BLE_MTU_REFRESH_RETRY_DELAY_MS);
+                    refreshAttempts += 1;
+                    refreshedDevice = yield requestNegotiatedMtu(transport$1.device, 'servicesAndNotifyReady', 2);
+                    transport$1.device = refreshedDevice;
+                    transport$1.mtuSize =
+                        typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport$1.mtuSize;
+                }
+            }
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE MTU ready', {
+                platform: reactNative.Platform.OS,
+                requested: getRequestedBleMtu(),
+                initial: initialMtu,
+                actual: transport$1.mtuSize,
+                refreshAttempts,
+            });
+            return transport$1;
+        });
+    }
     acquire(input) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -727,9 +820,8 @@ class ReactNativeBleTransport {
             if (forceCleanRunPromise && this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
-                this.rejectAllProtocolV2Frames(error);
                 this.runPromise = null;
-                this.activeProtocolV2Call = null;
+                this.runPromiseDeviceId = null;
                 Log === null || Log === void 0 ? void 0 : Log.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
             }
             const blePlxManager = yield this.getPlxManager();
@@ -762,14 +854,17 @@ class ReactNativeBleTransport {
             if (!device) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device: ', uuid);
                 try {
-                    device = yield blePlxManager.connectToDevice(uuid, connectOptions);
+                    device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, connectOptions));
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('try to connect to device has error: ', e);
+                    if (isConnectTimeoutError(e)) {
+                        throw e;
+                    }
                     if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
                         e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('first try to reconnect without params');
-                        device = yield blePlxManager.connectToDevice(uuid);
+                        device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, fallbackConnectOptions));
                     }
                     else if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('device already connected');
@@ -785,23 +880,27 @@ class ReactNativeBleTransport {
             }
             if (!(yield device.isConnected())) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device: ', uuid);
+                const disconnectedDevice = device;
                 try {
-                    device = yield device.connect(connectOptions);
+                    device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(connectOptions));
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('not connected, try to connect to device has error: ', e);
+                    if (isConnectTimeoutError(e)) {
+                        throw e;
+                    }
                     if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
                         e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('second try to reconnect without params');
                         try {
-                            device = yield device.connect();
+                            device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
                         }
                         catch (e) {
                             Log === null || Log === void 0 ? void 0 : Log.debug('last try to reconnect error: ', e);
                             if (e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                                 Log === null || Log === void 0 ? void 0 : Log.debug('last try to reconnect');
-                                yield device.cancelConnection();
-                                device = yield device.connect();
+                                yield disconnectedDevice.cancelConnection();
+                                device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
                             }
                         }
                     }
@@ -810,51 +909,42 @@ class ReactNativeBleTransport {
                     }
                 }
             }
-            device = yield requestAndroidMtu(device);
-            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristics(device);
+            device = yield resolveNegotiatedMtu(device);
+            const acquiredDevice = device;
+            const { writeCharacteristic, notifyCharacteristic } = yield this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice);
             const protocolHint = expectedProtocol
                 ? undefined
-                : (_a = this.deviceProtocolHints.get(uuid)) !== null && _a !== void 0 ? _a : inferProtocolHintFromDeviceName(getDeviceDisplayName(device));
+                : (_b = (_a = input.protocolHint) !== null && _a !== void 0 ? _a : this.deviceProtocolHints.get(uuid)) !== null && _b !== void 0 ? _b : inferProtocolHintFromDeviceName(getDeviceDisplayName(acquiredDevice));
             yield this.release(uuid, true);
             if (protocolHint) {
                 this.deviceProtocolHints.set(uuid, protocolHint);
             }
-            const transport$1 = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
-            if (reactNative.Platform.OS === 'android') {
-                transport$1.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport$1.mtuSize;
-            }
-            const monitorToken = this.nextMonitorToken;
-            this.nextMonitorToken += 1;
-            const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
-            transport$1.monitorToken = monitorToken;
-            transport$1.notifyTransactionId = notifyTransactionId;
-            this.monitorTokens.set(uuid, monitorToken);
-            transport$1.notifySubscription = this._monitorCharacteristic(transport$1.notifyCharacteristic, uuid, monitorToken, notifyTransactionId);
-            transportCache[uuid] = transport$1;
-            this.protocolV2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler());
-            if (reactNative.Platform.OS === 'ios') {
-                yield new Promise(resolve => {
-                    setTimeout(resolve, IOS_NOTIFY_READY_DELAY_MS);
-                });
+            yield this.installTransportForAcquire(uuid, acquiredDevice, {
+                writeCharacteristic,
+                notifyCharacteristic,
+            });
+            try {
+                const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint, () => __awaiter(this, void 0, void 0, function* () {
+                    yield this.installTransportForAcquire(uuid, acquiredDevice);
+                }));
+                const currentTransport = transportCache[uuid];
+                if (!currentTransport) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
+                }
+                this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
+                return { uuid, protocolType };
             }
-            else if (reactNative.Platform.OS === 'android') {
-                yield delay(ANDROID_NOTIFY_READY_DELAY_MS);
+            catch (error) {
+                yield this.release(uuid, true);
+                throw error;
             }
-            const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint);
-            (_b = this.emitter) === null || _b === void 0 ? void 0 : _b.emit('device-connect', {
-                name: device.name,
-                id: device.id,
-                connectId: device.id,
-            });
-            this.attachDisconnectSubscription(transport$1, device, uuid);
-            return { uuid, protocolType };
         });
     }
     _monitorCharacteristic(characteristic, uuid, monitorToken, notifyTransactionId) {
         let bufferLength = 0;
         let buffer$1 = [];
         const subscription = characteristic.monitor((error, c) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
             const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
             if (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug(`error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${error}`);
@@ -866,28 +956,44 @@ class ReactNativeBleTransport {
                     Log === null || Log === void 0 ? void 0 : Log.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
                     return;
                 }
-                if (this.runPromise) {
-                    let ERROR = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
+                if (this.getActiveProtocol(uuid) === 'V2') {
+                    let errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
                     if ((_a = error.reason) === null || _a === void 0 ? void 0 : _a.includes('The connection has timed out unexpectedly')) {
-                        ERROR = hdShared.HardwareErrorCode.BleTimeoutError;
+                        errorCode = hdShared.HardwareErrorCode.BleTimeoutError;
                     }
-                    if ((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('Encryption is insufficient')) {
-                        ERROR = hdShared.HardwareErrorCode.BleDeviceBondError;
+                    else if ((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('Encryption is insufficient')) {
+                        errorCode = hdShared.HardwareErrorCode.BleDeviceBondError;
                     }
-                    if (((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('Cannot write client characteristic config descriptor')) ||
+                    else if (((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('Cannot write client characteristic config descriptor')) ||
                         ((_d = error.reason) === null || _d === void 0 ? void 0 : _d.includes('Cannot find client characteristic config descriptor')) ||
                         ((_e = error.reason) === null || _e === void 0 ? void 0 : _e.includes('The handle is invalid')) ||
                         ((_f = error.reason) === null || _f === void 0 ? void 0 : _f.includes('Writing is not permitted')) ||
                         ((_g = error.reason) === null || _g === void 0 ? void 0 : _g.includes('notify change failed for device'))) {
+                        errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
+                    }
+                    this.rejectProtocolV2Frames(uuid, hdShared.ERRORS.TypedError(errorCode));
+                    return;
+                }
+                if (this.runPromise && this.runPromiseDeviceId === uuid) {
+                    let ERROR = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
+                    if ((_h = error.reason) === null || _h === void 0 ? void 0 : _h.includes('The connection has timed out unexpectedly')) {
+                        ERROR = hdShared.HardwareErrorCode.BleTimeoutError;
+                    }
+                    if ((_j = error.reason) === null || _j === void 0 ? void 0 : _j.includes('Encryption is insufficient')) {
+                        ERROR = hdShared.HardwareErrorCode.BleDeviceBondError;
+                    }
+                    if (((_k = error.reason) === null || _k === void 0 ? void 0 : _k.includes('Cannot write client characteristic config descriptor')) ||
+                        ((_l = error.reason) === null || _l === void 0 ? void 0 : _l.includes('Cannot find client characteristic config descriptor')) ||
+                        ((_m = error.reason) === null || _m === void 0 ? void 0 : _m.includes('The handle is invalid')) ||
+                        ((_o = error.reason) === null || _o === void 0 ? void 0 : _o.includes('Writing is not permitted')) ||
+                        ((_p = error.reason) === null || _p === void 0 ? void 0 : _p.includes('notify change failed for device'))) {
                         const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
                         this.runPromise.reject(notifyError);
-                        this.rejectAllProtocolV2Frames(notifyError);
                         Log === null || Log === void 0 ? void 0 : Log.debug(`${hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`);
                         return;
                     }
                     const notifyError = hdShared.ERRORS.TypedError(ERROR);
                     this.runPromise.reject(notifyError);
-                    this.rejectAllProtocolV2Frames(notifyError);
                     Log === null || Log === void 0 ? void 0 : Log.debug(': monitor notify error, and has unreleased Promise', Error);
                 }
                 return;
@@ -901,13 +1007,13 @@ class ReactNativeBleTransport {
             }
             try {
                 const data = buffer.Buffer.from(c.value, 'base64');
-                const protocol = this.deviceProtocol.get(uuid);
+                const protocol = this.getActiveProtocol(uuid);
                 if (!protocol) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('monitor data ignored before protocol detection: ', uuid);
                     return;
                 }
                 if (protocol === 'V2') {
-                    this.handleProtocolV2Notification(uuid, new Uint8Array(data));
+                    this.handleProtocolV2Notification(uuid, monitorToken, new Uint8Array(data));
                     return;
                 }
                 if (isHeaderChunk(data)) {
@@ -921,28 +1027,40 @@ class ReactNativeBleTransport {
                     const value = buffer.Buffer.from(buffer$1);
                     bufferLength = 0;
                     buffer$1 = [];
-                    (_h = this.runPromise) === null || _h === void 0 ? void 0 : _h.resolve(value.toString('hex'));
+                    if (this.runPromiseDeviceId === uuid) {
+                        (_q = this.runPromise) === null || _q === void 0 ? void 0 : _q.resolve(value.toString('hex'));
+                    }
                 }
             }
             catch (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('monitor data error: ', error);
                 const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
-                (_j = this.runPromise) === null || _j === void 0 ? void 0 : _j.reject(notifyError);
-                this.rejectAllProtocolV2Frames(notifyError);
+                if (this.getActiveProtocol(uuid) === 'V2') {
+                    this.rejectProtocolV2Frames(uuid, notifyError);
+                }
+                else if (this.runPromiseDeviceId === uuid) {
+                    (_r = this.runPromise) === null || _r === void 0 ? void 0 : _r.reject(notifyError);
+                }
             }
         }, notifyTransactionId);
         return subscription;
     }
     release(uuid, onclose = false) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2Links.invalidateLink(uuid, 'React Native BLE transport released');
+            return this.releaseNative(uuid, onclose);
+        });
+    }
+    releaseNative(uuid, onclose = false) {
+        var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
             const transport = transportCache[uuid];
-            if (this.runPromise) {
+            if (this.runPromise && this.runPromiseDeviceId === uuid) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
                 this.runPromise = null;
-                this.rejectAllProtocolV2Frames(error);
-                this.activeProtocolV2Call = null;
+                this.runPromiseDeviceId = null;
+                this.rejectProtocolV2Frames(uuid, error);
             }
             else {
                 this.resetProtocolV2Frames(uuid);
@@ -950,24 +1068,22 @@ class ReactNativeBleTransport {
             if (reactNative.Platform.OS === 'android' && !onclose && transport) {
                 (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
                 this.resetProtocolV2Frames(uuid);
-                if (((_b = this.activeProtocolV2Call) === null || _b === void 0 ? void 0 : _b.uuid) === uuid) {
-                    this.activeProtocolV2Call = null;
-                }
                 return Promise.resolve(true);
             }
+            yield this.restoreAndroidConnectionPriority(uuid, transport);
             if (transport) {
                 if (this.monitorTokens.get(uuid) === transport.monitorToken) {
                     this.monitorTokens.delete(uuid);
                 }
                 Log === null || Log === void 0 ? void 0 : Log.debug('release: removing disconnect subscription for device: ', uuid);
-                (_c = transport.disconnectSubscription) === null || _c === void 0 ? void 0 : _c.remove();
+                (_b = transport.disconnectSubscription) === null || _b === void 0 ? void 0 : _b.remove();
                 transport.disconnectSubscription = undefined;
-                Log === null || Log === void 0 ? void 0 : Log.debug('release: removing notify subscription, characteristic: ', (_d = transport.notifyCharacteristic) === null || _d === void 0 ? void 0 : _d.uuid);
-                (_e = transport.notifySubscription) === null || _e === void 0 ? void 0 : _e.remove();
+                Log === null || Log === void 0 ? void 0 : Log.debug('release: removing notify subscription, characteristic: ', (_c = transport.notifyCharacteristic) === null || _c === void 0 ? void 0 : _c.uuid);
+                (_d = transport.notifySubscription) === null || _d === void 0 ? void 0 : _d.remove();
                 transport.notifySubscription = undefined;
                 if (transport.notifyTransactionId) {
                     try {
-                        yield ((_f = this.blePlxManager) === null || _f === void 0 ? void 0 : _f.cancelTransaction(transport.notifyTransactionId));
+                        yield ((_e = this.blePlxManager) === null || _e === void 0 ? void 0 : _e.cancelTransaction(transport.notifyTransactionId));
                     }
                     catch (e) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('release: cancel notify transaction error (ignored): ', (e === null || e === void 0 ? void 0 : e.message) || e);
@@ -975,13 +1091,14 @@ class ReactNativeBleTransport {
                 }
                 delete transportCache[uuid];
             }
+            this.protocolV2HighVolumeLogSignatures.delete(uuid);
             this.deviceProtocol.delete(uuid);
-            this.deviceProtocolHints.delete(uuid);
-            (_g = this.protocolV2Assemblers.get(uuid)) === null || _g === void 0 ? void 0 : _g.reset();
+            this.probingProtocols.delete(uuid);
+            (_f = this.protocolV2Assemblers.get(uuid)) === null || _f === void 0 ? void 0 : _f.reset();
             this.protocolV2Assemblers.delete(uuid);
             this.resetProtocolV2Frames(uuid);
             try {
-                yield ((_h = this.blePlxManager) === null || _h === void 0 ? void 0 : _h.cancelTransaction(uuid));
+                yield ((_g = this.blePlxManager) === null || _g === void 0 ? void 0 : _g.cancelTransaction(uuid));
             }
             catch (e) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('release: cancel transaction error (ignored): ', (e === null || e === void 0 ? void 0 : e.message) || e);
@@ -1002,30 +1119,18 @@ class ReactNativeBleTransport {
             if (this._messages == null) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const forceRun = name === 'Initialize' || name === 'Cancel';
-            Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native call this.runPromise', this.runPromise);
-            if (this.runPromise && !forceRun) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
-            }
             const protocol = this.getProtocolType(uuid);
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
-            if (name === 'ResourceUpdate' || name === 'ResourceAck') {
-                Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', {
-                    file_name: data === null || data === void 0 ? void 0 : data.file_name,
-                    hash: data === null || data === void 0 ? void 0 : data.hash,
-                });
-            }
-            else if (transport.LogBlockCommand.has(name)) {
-                Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name, ' protocol: ', protocol);
-            }
-            else {
-                Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
-            }
+            Log === null || Log === void 0 ? void 0 : Log.debug('transport call', transport.createTransportCallLog(name, protocol, data));
             if (protocol === 'V2') {
                 return this.callProtocolV2(uuid, name, data, options);
             }
+            const forceRun = name === 'Initialize' || name === 'Cancel';
+            if (this.runPromise && !forceRun) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
+            }
             return this.callProtocolV1(uuid, name, data, options);
         });
     }
@@ -1037,7 +1142,19 @@ class ReactNativeBleTransport {
             const transport = this.getCachedTransport(uuid);
             const runPromise = hdShared.createDeferred();
             runPromise.promise.catch(() => undefined);
+            const supersededRunPromise = this.runPromise;
+            if (supersededRunPromise) {
+                supersededRunPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise));
+            }
             this.runPromise = runPromise;
+            this.runPromiseDeviceId = uuid;
+            const releaseOwnershipIfCurrent = () => {
+                if (this.runPromise === runPromise) {
+                    this.runPromise = null;
+                    this.runPromiseDeviceId = null;
+                }
+            };
+            const isCurrentOwner = () => this.runPromise === runPromise;
             const messages = this._messages;
             const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
             let timeout;
@@ -1058,6 +1175,9 @@ class ReactNativeBleTransport {
                             }
                             catch (e) {
                                 onError(e);
+                                if (isWedgedWriteError(e)) {
+                                    throw e;
+                                }
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
                             }
                         }
@@ -1085,6 +1205,9 @@ class ReactNativeBleTransport {
                             }
                             catch (e) {
                                 onError(e);
+                                if (isWedgedWriteError(e)) {
+                                    throw e;
+                                }
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
                             }
                         }
@@ -1095,13 +1218,13 @@ class ReactNativeBleTransport {
                 });
             }
             if (name === 'EmmcFileWrite') {
-                yield writeChunkedData(buffers, data => transport.writeWithRetry(data), e => {
-                    this.runPromise = null;
+                yield writeChunkedData(buffers, data => this.writeBlePacket(uuid, data, payload => transport.writeWithRetry(payload), isCurrentOwner), e => {
+                    releaseOwnershipIfCurrent();
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
                 });
             }
             else if (name === 'FirmwareUpload') {
-                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] FirmwareUpload write uses throttled BLE packets:', {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Firmware upload transport configured', {
                     packetCapacity: FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY,
                     burstSize: FIRMWARE_UPLOAD_WRITE_BURST_SIZE,
                     pauseMs: FIRMWARE_UPLOAD_WRITE_PAUSE_MS,
@@ -1112,7 +1235,7 @@ class ReactNativeBleTransport {
                     let attempt = 0;
                     while (true) {
                         try {
-                            yield transport.writeCharacteristic.writeWithoutResponse(data);
+                            yield this.writeBlePacket(uuid, data, payload => transport.writeWithRetry(payload), isCurrentOwner);
                             return;
                         }
                         catch (error) {
@@ -1120,36 +1243,18 @@ class ReactNativeBleTransport {
                             if (!retryType || attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
                                 throw error;
                             }
-                            const shouldReconnect = retryType === 'reconnectable';
-                            const delayMs = shouldReconnect
-                                ? FIRMWARE_UPLOAD_RECONNECT_RETRY_DELAY_MS
-                                : resolveFirmwareUploadRetryDelay(attempt);
+                            const delayMs = resolveFirmwareUploadRetryDelay(attempt);
                             Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] FirmwareUpload write retry:', {
                                 attempt: attempt + 1,
                                 delayMs,
-                                reconnect: shouldReconnect,
                                 error,
                             });
-                            if (shouldReconnect) {
-                                this.firmwareUploadWriteRecoveryIds.add(uuid);
-                            }
                             yield delay(delayMs);
                             attempt += 1;
-                            if (shouldReconnect) {
-                                try {
-                                    yield this.reconnectFirmwareUploadTransport(uuid, transport);
-                                }
-                                catch (e) {
-                                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] FirmwareUpload reconnect error:', e);
-                                    if (attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
-                                        throw e;
-                                    }
-                                }
-                            }
                         }
                     }
                 }), e => {
-                    this.runPromise = null;
+                    releaseOwnershipIfCurrent();
                     Log === null || Log === void 0 ? void 0 : Log.error('writeCharacteristic write error: ', e);
                 });
             }
@@ -1157,11 +1262,17 @@ class ReactNativeBleTransport {
                 for (const o of buffers) {
                     const outData = o.toString('base64');
                     try {
-                        yield transport.writeCharacteristic.writeWithoutResponse(outData);
+                        const shouldUseWriteWithResponse = reactNative.Platform.OS === 'ios' && transport.writeCharacteristic.isWritableWithResponse;
+                        yield this.writeBlePacket(uuid, outData, payload => shouldUseWriteWithResponse
+                            ? transport.writeCharacteristic.writeWithResponse(payload)
+                            : transport.writeCharacteristic.writeWithoutResponse(payload), isCurrentOwner);
                     }
                     catch (e) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('writeCharacteristic write error: ', e);
-                        this.runPromise = null;
+                        releaseOwnershipIfCurrent();
+                        if (isWedgedWriteError(e)) {
+                            throw e;
+                        }
                         if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceDisconnected) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded);
                         }
@@ -1190,17 +1301,23 @@ class ReactNativeBleTransport {
                 if (typeof response !== 'string') {
                     throw new Error('Returning data is not string.');
                 }
-                Log === null || Log === void 0 ? void 0 : Log.debug('receive data: ', response);
                 const jsonData = ProtocolV1.decodeMessage(messages, response);
                 return check.call(jsonData);
             }
             catch (e) {
-                if (name === 'Initialize' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe call failed:', e);
+                if (name === 'GetFeatures' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe call failed:', e);
                 }
                 else {
                     Log === null || Log === void 0 ? void 0 : Log.error('call error: ', e);
                 }
+                const isProbeTimeout = name === 'GetFeatures' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS;
+                const isStaleCall = this.runPromise !== runPromise;
+                if (!isProbeTimeout &&
+                    !isStaleCall &&
+                    (e === null || e === void 0 ? void 0 : e.errorCode) === hdShared.HardwareErrorCode.BleTimeoutError) {
+                    yield this.disconnect(uuid);
+                }
                 throw e;
             }
             finally {
@@ -1208,6 +1325,7 @@ class ReactNativeBleTransport {
                     clearTimeout(timeout);
                 if (this.runPromise === runPromise) {
                     this.runPromise = null;
+                    this.runPromiseDeviceId = null;
                 }
             }
         });
@@ -1216,10 +1334,11 @@ class ReactNativeBleTransport {
         this.stopped = true;
     }
     disconnect(session) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native transport resetSession: ', session);
+            yield this.protocolV2Links.invalidateLink(session, 'React Native BLE transport disconnected');
             const transport = transportCache[session];
+            const monitorToken = (_a = transport === null || transport === void 0 ? void 0 : transport.monitorToken) !== null && _a !== void 0 ? _a : this.monitorTokens.get(session);
             if (transport === null || transport === void 0 ? void 0 : transport.disconnectSubscription) {
                 try {
                     Log === null || Log === void 0 ? void 0 : Log.debug('disconnect: removing disconnect subscription');
@@ -1232,7 +1351,7 @@ class ReactNativeBleTransport {
             }
             if (transport === null || transport === void 0 ? void 0 : transport.notifySubscription) {
                 try {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('disconnect: removing notify subscription, characteristic: ', (_a = transport.notifyCharacteristic) === null || _a === void 0 ? void 0 : _a.uuid);
+                    Log === null || Log === void 0 ? void 0 : Log.debug('disconnect: removing notify subscription, characteristic: ', (_b = transport.notifyCharacteristic) === null || _b === void 0 ? void 0 : _b.uuid);
                     transport.notifySubscription.remove();
                     transport.notifySubscription = undefined;
                 }
@@ -1242,7 +1361,7 @@ class ReactNativeBleTransport {
             }
             if (session) {
                 try {
-                    yield ((_b = this.blePlxManager) === null || _b === void 0 ? void 0 : _b.cancelTransaction(session));
+                    yield ((_c = this.blePlxManager) === null || _c === void 0 ? void 0 : _c.cancelTransaction(session));
                 }
                 catch (e) {
                     Log === null || Log === void 0 ? void 0 : Log.debug('resetSession: cancel transaction error (ignored): ', (e === null || e === void 0 ? void 0 : e.message) || e);
@@ -1257,7 +1376,7 @@ class ReactNativeBleTransport {
                 }
             }
             try {
-                yield ((_c = this.blePlxManager) === null || _c === void 0 ? void 0 : _c.cancelDeviceConnection(session));
+                yield ((_d = this.blePlxManager) === null || _d === void 0 ? void 0 : _d.cancelDeviceConnection(session));
             }
             catch (e) {
                 Log === null || Log === void 0 ? void 0 : Log.debug('resetSession: manager.cancelDeviceConnection error (ignored): ', (e === null || e === void 0 ? void 0 : e.message) || e);
@@ -1266,22 +1385,21 @@ class ReactNativeBleTransport {
                 delete transportCache[session];
             }
             this.deviceProtocol.delete(session);
+            this.probingProtocols.delete(session);
             this.deviceProtocolHints.delete(session);
+            this.sessionProtocols.delete(session);
+            this.protocolReprobeFailures.delete(session);
             this.protocolV2Assemblers.delete(session);
             this.resetProtocolV2Frames(session);
-            if (((_d = this.activeProtocolV2Call) === null || _d === void 0 ? void 0 : _d.uuid) === session) {
-                this.activeProtocolV2Call = null;
-            }
             try {
-                (_e = this.emitter) === null || _e === void 0 ? void 0 : _e.emit('device-disconnect', {
-                    name: (_f = transport === null || transport === void 0 ? void 0 : transport.device) === null || _f === void 0 ? void 0 : _f.name,
-                    id: session,
-                    connectId: session,
-                });
+                this.emitDeviceDisconnect(session, (_e = transport === null || transport === void 0 ? void 0 : transport.device) === null || _e === void 0 ? void 0 : _e.name, monitorToken);
             }
             catch (e) {
                 Log === null || Log === void 0 ? void 0 : Log.error('resetSession: emit disconnect event error: ', e);
             }
+            if (monitorToken !== undefined && this.monitorTokens.get(session) === monitorToken) {
+                this.monitorTokens.delete(session);
+            }
             yield new Promise(resolve => setTimeout(() => resolve(), 100));
         });
     }
@@ -1289,6 +1407,92 @@ class ReactNativeBleTransport {
         Log === null || Log === void 0 ? void 0 : Log.debug('transport-react-native transport cancel');
         if (this.runPromise) ;
         this.runPromise = null;
+        this.runPromiseDeviceId = null;
+    }
+    connectWithTimeout(uuid, connect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            const pending = connect();
+            pending.catch(() => undefined);
+            try {
+                const result = yield Promise.race([
+                    pending,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `BLE connect timeout after ${BLE_CONNECT_TIMEOUT_MS}ms for ${uuid}`));
+                        }, BLE_CONNECT_TIMEOUT_MS);
+                    }),
+                ]);
+                return result;
+            }
+            catch (error) {
+                if (timedOut || isNativeOperationTimeoutError(error)) {
+                    this.abandonStalledConnection(uuid, timedOut ? 'connect-backstop' : 'connect-native');
+                }
+                throw error;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    resolveCharacteristicsWithTimeout(uuid, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            const pending = this.resolveCharacteristics(device);
+            pending.catch(() => undefined);
+            try {
+                const result = yield Promise.race([
+                    pending,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `BLE GATT setup timeout after ${BLE_GATT_SETUP_TIMEOUT_MS}ms for ${uuid}`));
+                        }, BLE_GATT_SETUP_TIMEOUT_MS);
+                    }),
+                ]);
+                this.connectionSetupTimeoutCounts.delete(uuid);
+                return result;
+            }
+            catch (error) {
+                if (timedOut || isNativeOperationTimeoutError(error)) {
+                    this.abandonStalledConnection(uuid, timedOut ? 'gatt-backstop' : 'gatt-native');
+                }
+                throw error;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    abandonStalledConnection(uuid, stage) {
+        var _a, _b;
+        const timeouts = ((_a = this.connectionSetupTimeoutCounts.get(uuid)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.connectionSetupTimeoutCounts.set(uuid, timeouts);
+        Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE setup timed out:', uuid, {
+            stage,
+            setupTimeoutsSinceSuccess: timeouts,
+        });
+        (_b = this.blePlxManager) === null || _b === void 0 ? void 0 : _b.cancelDeviceConnection(uuid).catch(() => {
+        });
+        const stalled = transportCache[uuid];
+        if (stalled) {
+            delete transportCache[uuid];
+        }
+        this.deviceProtocol.delete(uuid);
+        this.probingProtocols.delete(uuid);
+        this.protocolV2Assemblers.delete(uuid);
+        this.resetProtocolV2Frames(uuid);
+        if (timeouts >= BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD) {
+            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE setup wedged repeatedly, resetting BLE manager');
+            this.resetPlxManager();
+            this.connectionSetupTimeoutCounts.delete(uuid);
+        }
     }
     getCachedTransport(uuid) {
         const transport = transportCache[uuid];
@@ -1297,58 +1501,189 @@ class ReactNativeBleTransport {
         }
         return transport;
     }
+    writeBlePacket(uuid, data, write, isCurrentOwner) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            try {
+                yield Promise.race([
+                    write(data),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            timedOut = true;
+                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError, `BLE write timeout after ${BLE_WRITE_PACKET_TIMEOUT_MS}ms`));
+                        }, BLE_WRITE_PACKET_TIMEOUT_MS);
+                    }),
+                ]);
+                this.writeTimeoutCounts.delete(uuid);
+            }
+            catch (error) {
+                if (timedOut) {
+                    if (isCurrentOwner && !isCurrentOwner()) {
+                        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] stale BLE write timed out, link kept:', uuid);
+                    }
+                    else {
+                        this.tearDownWedgedLink(uuid);
+                    }
+                }
+                throw error;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    tearDownWedgedLink(uuid) {
+        var _a;
+        const timeouts = ((_a = this.writeTimeoutCounts.get(uuid)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.writeTimeoutCounts.set(uuid, timeouts);
+        Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE write timed out, tearing down link:', uuid, {
+            consecutiveWriteTimeouts: timeouts,
+        });
+        const wedged = transportCache[uuid];
+        this.disconnect(uuid).catch(error => {
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] wedged link teardown failed (ignored):', error);
+        });
+        if (wedged && transportCache[uuid] === wedged) {
+            delete transportCache[uuid];
+        }
+        this.deviceProtocol.delete(uuid);
+        this.probingProtocols.delete(uuid);
+        this.protocolV2Assemblers.delete(uuid);
+        this.resetProtocolV2Frames(uuid);
+        if (timeouts >= BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD) {
+            Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] BLE writes wedged repeatedly, resetting BLE manager');
+            this.resetPlxManager();
+            this.writeTimeoutCounts.delete(uuid);
+        }
+    }
+    resetPlxManager() {
+        const manager = this.blePlxManager;
+        this.blePlxManager = undefined;
+        Object.keys(transportCache).forEach(key => {
+            delete transportCache[key];
+        });
+        this.deviceProtocol.clear();
+        this.probingProtocols.clear();
+        this.sessionProtocols.clear();
+        this.protocolReprobeFailures.clear();
+        this.writeTimeoutCounts.clear();
+        this.connectionSetupTimeoutCounts.clear();
+        this.monitorTokens.clear();
+        this.protocolV2Assemblers.clear();
+        try {
+            manager === null || manager === void 0 ? void 0 : manager.destroy();
+        }
+        catch (error) {
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE manager destroy failed (ignored):', error);
+        }
+    }
     createProtocolMismatchError(expected) {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
     }
     createProtocolDetectionError() {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping');
     }
     clearProbeProtocol(uuid, protocol) {
+        if (this.probingProtocols.get(uuid) === protocol) {
+            this.probingProtocols.delete(uuid);
+        }
         if (this.deviceProtocol.get(uuid) === protocol) {
             this.deviceProtocol.delete(uuid);
         }
     }
-    detectProtocol(uuid, expectedProtocol, protocolHint) {
+    getActiveProtocol(uuid) {
+        var _a;
+        return (_a = this.deviceProtocol.get(uuid)) !== null && _a !== void 0 ? _a : this.probingProtocols.get(uuid);
+    }
+    detectProtocol(uuid, expectedProtocol, protocolHint, rebuildTransport) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            if (reactNative.Platform.OS === 'ios' && expectedProtocol) {
+                this.deviceProtocol.set(uuid, expectedProtocol);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol selected', {
+                    deviceId: uuid,
+                    protocol: expectedProtocol,
+                    source: 'expected',
+                });
+                return expectedProtocol;
+            }
             if (expectedProtocol === 'V1') {
                 if (yield this.probeProtocolV1(uuid)) {
                     this.deviceProtocol.set(uuid, 'V1');
-                    Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+                    this.sessionProtocols.set(uuid, 'V1');
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
+                        deviceId: uuid,
+                        protocol: 'V1',
+                        source: 'expected',
+                    });
                     return 'V1';
                 }
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
             if (expectedProtocol === 'V2') {
-                this.deviceProtocol.set(uuid, 'V2');
-                Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
-                return 'V2';
+                if (yield this.probeProtocolV2(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V2');
+                    this.sessionProtocols.set(uuid, 'V2');
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
+                        deviceId: uuid,
+                        protocol: 'V2',
+                        source: 'expected',
+                    });
+                    return 'V2';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
             }
-            const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            const sessionProtocol = this.sessionProtocols.get(uuid);
+            const reprobeFailures = (_a = this.protocolReprobeFailures.get(uuid)) !== null && _a !== void 0 ? _a : 0;
+            const fullProbeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            const trustSessionProtocol = sessionProtocol !== undefined &&
+                !protocolHint &&
+                reprobeFailures < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
+            const probeOrder = trustSessionProtocol ? [sessionProtocol] : fullProbeOrder;
             for (let i = 0; i < probeOrder.length; i += 1) {
                 const protocol = probeOrder[i];
                 if (i > 0) {
                     yield this.resetProbeStateAfterProtocolProbe(uuid, probeOrder[i - 1]);
+                    if (!transportCache[uuid]) {
+                        if (!rebuildTransport) {
+                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
+                        }
+                        yield rebuildTransport();
+                    }
                 }
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
                 if (detected) {
                     this.deviceProtocol.set(uuid, protocol);
-                    Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] detectProtocol: uuid=${uuid} -> ${protocol}`);
+                    this.sessionProtocols.set(uuid, protocol);
+                    this.protocolReprobeFailures.delete(uuid);
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
+                        deviceId: uuid,
+                        protocol,
+                        source: 'probe',
+                    });
                     return protocol;
                 }
             }
+            if (trustSessionProtocol) {
+                this.protocolReprobeFailures.set(uuid, reprobeFailures + 1);
+            }
+            else {
+                this.protocolReprobeFailures.delete(uuid);
+            }
             this.deviceProtocol.delete(uuid);
+            this.probingProtocols.delete(uuid);
             throw this.createProtocolDetectionError();
         });
     }
     resetProbeStateAfterProtocolProbe(uuid, protocol) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const transport = transportCache[uuid];
+            yield this.protocolV2Links.invalidateLink(uuid, `Reset notify state after Protocol ${protocol} probe`);
             (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             this.resetProtocolV2Frames(uuid);
-            if (((_b = this.activeProtocolV2Call) === null || _b === void 0 ? void 0 : _b.uuid) === uuid) {
-                this.activeProtocolV2Call = null;
-            }
             if (this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
@@ -1360,11 +1695,11 @@ class ReactNativeBleTransport {
             if (this.monitorTokens.get(uuid) === transport.monitorToken) {
                 this.monitorTokens.delete(uuid);
             }
-            (_c = transport.notifySubscription) === null || _c === void 0 ? void 0 : _c.remove();
+            (_b = transport.notifySubscription) === null || _b === void 0 ? void 0 : _b.remove();
             transport.notifySubscription = undefined;
             if (previousNotifyTransactionId) {
                 try {
-                    yield ((_d = this.blePlxManager) === null || _d === void 0 ? void 0 : _d.cancelTransaction(previousNotifyTransactionId));
+                    yield ((_c = this.blePlxManager) === null || _c === void 0 ? void 0 : _c.cancelTransaction(previousNotifyTransactionId));
                 }
                 catch (error) {
                     Log === null || Log === void 0 ? void 0 : Log.debug(`[ReactNativeBleTransport] cancel notify after Protocol ${protocol} probe failed:`, (error === null || error === void 0 ? void 0 : error.message) || error);
@@ -1390,13 +1725,17 @@ class ReactNativeBleTransport {
                 return false;
             }
             try {
-                this.deviceProtocol.set(uuid, 'V1');
-                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+                this.probingProtocols.set(uuid, 'V1');
+                yield this.callProtocolV1(uuid, 'GetFeatures', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+                this.probingProtocols.delete(uuid);
                 return true;
             }
             catch (error) {
                 this.clearProbeProtocol(uuid, 'V1');
-                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe failed:', error);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe failed:', error);
+                if (isWedgedWriteError(error)) {
+                    throw error;
+                }
                 return false;
             }
         });
@@ -1407,7 +1746,7 @@ class ReactNativeBleTransport {
             if (!this._messages || !this._messagesV2) {
                 return false;
             }
-            this.deviceProtocol.set(uuid, 'V2');
+            this.probingProtocols.set(uuid, 'V2');
             (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             const detected = yield transport.probeProtocolV2({
                 call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
@@ -1423,17 +1762,16 @@ class ReactNativeBleTransport {
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');
             }
+            else {
+                this.probingProtocols.delete(uuid);
+            }
             return detected;
         });
     }
-    handleProtocolV2Notification(uuid, data) {
-        var _a, _b, _c;
+    handleProtocolV2Notification(uuid, monitorToken, data) {
         try {
-            if (!this.runPromise || ((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) !== uuid) {
-                (_b = this.protocolV2Assemblers.get(uuid)) === null || _b === void 0 ? void 0 : _b.reset();
-                this.resetProtocolV2Frames(uuid);
+            if (this.monitorTokens.get(uuid) !== monitorToken)
                 return;
-            }
             if (data.length === 0)
                 return;
             const assembler = this.protocolV2Assemblers.get(uuid);
@@ -1446,8 +1784,10 @@ class ReactNativeBleTransport {
         catch (error) {
             Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 notification error:', error);
             const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
-            (_c = this.runPromise) === null || _c === void 0 ? void 0 : _c.reject(notifyError);
-            this.rejectAllProtocolV2Frames(notifyError);
+            this.rejectProtocolV2Frames(uuid, notifyError);
+            this.protocolV2Links
+                .invalidateLink(uuid, `Protocol V2 notification error: ${error}`)
+                .catch(invalidateError => Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 notify cleanup failed:', invalidateError));
         }
     }
     getProtocolV2FrameQueue(uuid) {
@@ -1467,20 +1807,16 @@ class ReactNativeBleTransport {
         }
         this.getProtocolV2FrameQueue(uuid).push(frame);
     }
-    rejectAllProtocolV2Frames(error) {
-        this.protocolV2FrameQueues.clear();
-        for (const framePromise of this.protocolV2FramePromises.values()) {
-            framePromise.reject(error);
-        }
-        this.protocolV2FramePromises.clear();
-    }
     resetProtocolV2Frames(uuid) {
-        this.protocolV2FrameQueues.delete(uuid);
-        this.protocolV2FramePromises.delete(uuid);
+        this.rejectProtocolV2Frames(uuid, new Error(`Protocol V2 frame state reset for ${uuid}`));
     }
-    isActiveProtocolV2Call(uuid, token) {
-        var _a;
-        return ((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) === uuid && this.activeProtocolV2Call.token === token;
+    rejectProtocolV2Frames(uuid, error) {
+        this.protocolV2FrameQueues.delete(uuid);
+        const framePromise = this.protocolV2FramePromises.get(uuid);
+        if (framePromise) {
+            this.protocolV2FramePromises.delete(uuid);
+            framePromise.reject(error);
+        }
     }
     readProtocolV2Frame(uuid) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1500,146 +1836,255 @@ class ReactNativeBleTransport {
             }
         });
     }
-    writeProtocolV2Frame(transport, frame, options) {
+    writeProtocolV2Packet(uuid, transport, base64, context, assertCurrentGeneration) {
         return __awaiter(this, void 0, void 0, function* () {
-            const tuning = getProtocolV2BleTuning();
-            const packetCapacity = resolveProtocolV2PacketCapacity({
+            const shouldUseWriteWithResponse = shouldWriteProtocolV2WithResponse({
                 platform: reactNative.Platform.OS,
-                iosPacketLength: tuning.iosPacketLength,
-                androidPacketLength: tuning.androidPacketLength,
-                mtu: reactNative.Platform.OS === 'android' ? transport.mtuSize : undefined,
+                highThroughput: context.highThroughput,
+                requestedWithResponse: context.writeWithResponse,
+                characteristic: transport.writeCharacteristic,
             });
-            const writeWithResponse = !!(options === null || options === void 0 ? void 0 : options.writeWithResponse) || (!!(options === null || options === void 0 ? void 0 : options.highVolume) && tuning.highVolumeWriteWithResponse);
-            const writeMode = resolveBleWriteMode(transport.writeCharacteristic, writeWithResponse ? 'withResponse' : 'withoutResponse');
-            const shouldThrottle = !!(options === null || options === void 0 ? void 0 : options.highVolume) && writeMode === 'withoutResponse';
-            let packetsWritten = 0;
-            try {
-                for (let offset = 0; offset < frame.length; offset += packetCapacity) {
-                    const chunk = frame.slice(offset, offset + packetCapacity);
-                    const base64 = buffer.Buffer.from(chunk).toString('base64');
-                    if (writeMode === 'withResponse') {
-                        yield transport.writeCharacteristic.writeWithResponse(base64);
-                    }
-                    else {
-                        yield transport.writeCharacteristic.writeWithoutResponse(base64);
-                    }
-                    packetsWritten += 1;
-                    if (shouldThrottle &&
-                        packetsWritten % tuning.highVolumeWriteBurstSize === 0 &&
-                        offset + packetCapacity < frame.length) {
-                        yield delay(tuning.highVolumeWritePauseMs);
-                    }
+            let attempt = 0;
+            for (;;) {
+                assertCurrentGeneration();
+                if (context.signal.aborted) {
+                    throw new Error(`Protocol V2 BLE write aborted for ${context.messageName}`);
                 }
-                if (shouldThrottle) {
-                    yield delay(tuning.highVolumeWriteFlushDelayMs);
-                }
-            }
-            catch (error) {
-                if ((options === null || options === void 0 ? void 0 : options.highVolume) && !writeWithResponse && packetsWritten === 0) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 high-volume writeWithoutResponse failed before data was sent, fallback to writeWithResponse:', error);
-                    yield this.writeProtocolV2Frame(transport, frame, {
-                        highVolume: true,
-                        writeWithResponse: true,
+                try {
+                    yield this.writeBlePacket(uuid, base64, payload => shouldUseWriteWithResponse
+                        ? transport.writeCharacteristic.writeWithResponse(payload)
+                        : transport.writeCharacteristic.writeWithoutResponse(payload), () => {
+                        try {
+                            assertCurrentGeneration();
+                            return !context.signal.aborted;
+                        }
+                        catch (_a) {
+                            return false;
+                        }
                     });
+                    assertCurrentGeneration();
                     return;
                 }
-                throw error;
+                catch (error) {
+                    if (getFirmwareUploadWriteRetryType(error) !== 'congested' ||
+                        attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
+                        throw error;
+                    }
+                    const delayMs = resolveFirmwareUploadRetryDelay(attempt);
+                    attempt += 1;
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 congested write retry:', {
+                        name: context.messageName,
+                        attempt,
+                        delayMs,
+                    });
+                    yield delay(delayMs);
+                }
             }
         });
     }
+    writeProtocolV2Frame(uuid, transport$1, frame, context, assertCurrentGeneration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tuning = getProtocolV2BleTuning();
+            const packetCapacity = resolveProtocolV2PacketCapacity({
+                platform: reactNative.Platform.OS,
+                iosPacketLength: tuning.iosPacketLength,
+                androidPacketLength: tuning.androidPacketLength,
+                mtu: transport$1.mtuSize,
+            });
+            yield transport.writeProtocolV2BleFrame({
+                frame,
+                packetCapacity,
+                assertActive: assertCurrentGeneration,
+                signal: context.signal,
+                abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+                wait: delay,
+                writePacket: packet => this.writeProtocolV2Packet(uuid, transport$1, buffer.Buffer.from(packet).toString('base64'), context, assertCurrentGeneration),
+            });
+        });
+    }
     callProtocolV2(uuid, name, data, options) {
-        var _a, _b, _c, _d;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const forceRun = name === 'Initialize' || name === 'Cancel' || name === 'Ping';
-            if (this.runPromise) {
-                if (!forceRun) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
-                }
-                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
-                this.runPromise.reject(error);
-                this.rejectAllProtocolV2Frames(error);
-                this.runPromise = null;
-                this.activeProtocolV2Call = null;
-            }
-            const transport$1 = this.getCachedTransport(uuid);
-            const runPromise = hdShared.createDeferred();
-            runPromise.promise.catch(() => undefined);
-            this.runPromise = runPromise;
-            const callToken = this.nextProtocolV2CallToken++;
-            this.activeProtocolV2Call = { uuid, token: callToken };
-            (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
-            this.resetProtocolV2Frames(uuid);
-            let completed = false;
-            const callOptions = Object.assign(Object.assign({}, options), { timeoutMs: (_b = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _b !== void 0 ? _b : BLE_RESPONSE_TIMEOUT_MS });
-            const highVolumeWrite = transport.LogBlockCommand.has(name);
-            if (highVolumeWrite) {
+            const callOptions = options;
+            const highThroughputWrite = transport.isProtocolV2HighThroughputCall(name);
+            if (highThroughputWrite) {
+                yield this.ensureProtocolV2HighThroughputMtu(uuid);
                 const tuning = getProtocolV2BleTuning();
-                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 high-volume write uses throttled writeWithoutResponse:', name, {
-                    packetCapacity: reactNative.Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
-                    burstSize: tuning.highVolumeWriteBurstSize,
-                    pauseMs: tuning.highVolumeWritePauseMs,
-                    flushDelayMs: tuning.highVolumeWriteFlushDelayMs,
-                    writeWithResponse: tuning.highVolumeWriteWithResponse,
+                const currentTransport = this.getCachedTransport(uuid);
+                const writeWithResponse = shouldWriteProtocolV2WithResponse({
+                    platform: reactNative.Platform.OS,
+                    highThroughput: true,
+                    requestedWithResponse: options === null || options === void 0 ? void 0 : options.writeWithResponse,
+                    characteristic: currentTransport.writeCharacteristic,
+                });
+                const packetCapacity = resolveProtocolV2PacketCapacity({
+                    platform: reactNative.Platform.OS,
+                    iosPacketLength: tuning.iosPacketLength,
+                    androidPacketLength: tuning.androidPacketLength,
+                    mtu: currentTransport.mtuSize,
                 });
+                const writeMode = writeWithResponse ? 'withResponse' : 'withoutResponse';
+                const logSignature = `${name}:${writeMode}:${String(currentTransport.mtuSize)}:${packetCapacity}`;
+                const loggedSignatures = (_a = this.protocolV2HighVolumeLogSignatures.get(uuid)) !== null && _a !== void 0 ? _a : new Set();
+                if (!loggedSignatures.has(logSignature)) {
+                    loggedSignatures.add(logSignature);
+                    this.protocolV2HighVolumeLogSignatures.set(uuid, loggedSignatures);
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V2 high-volume write configured', {
+                        name,
+                        writeMode,
+                        reportedMtu: currentTransport.mtuSize,
+                        packetCapacity,
+                    });
+                }
+            }
+            if (highThroughputWrite) {
+                yield this.enableAndroidHighConnectionPriority(uuid);
             }
             try {
-                const session = new transport.ProtocolV2Session({
-                    schemas: {
-                        protocolV1: this._messages,
-                        protocolV2: this._messagesV2,
-                    },
-                    router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
-                    writeFrame: (frame) => __awaiter(this, void 0, void 0, function* () {
-                        yield this.writeProtocolV2Frame(transport$1, frame, {
-                            highVolume: highVolumeWrite,
-                        });
-                    }),
-                    readFrame: () => __awaiter(this, void 0, void 0, function* () {
-                        const rxFrame = yield this.readProtocolV2Frame(uuid);
-                        if (!(rxFrame instanceof Uint8Array)) {
-                            throw new Error('Protocol V2 response is not Uint8Array');
-                        }
-                        return rxFrame;
-                    }),
-                    logger: Log,
-                    logPrefix: 'ProtocolV2 RN-BLE',
-                    createTimeoutError: (_messageName, timeout) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE response timeout after ${timeout}ms for ${name}`),
-                });
-                const result = yield session.call(name, data, callOptions);
-                completed = true;
-                return result;
+                return yield this.protocolV2Links.call(uuid, () => this.createProtocolV2Adapter(uuid), name, data, callOptions);
             }
             catch (e) {
-                if (this.isActiveProtocolV2Call(uuid, callToken)) {
-                    (_c = this.protocolV2Assemblers.get(uuid)) === null || _c === void 0 ? void 0 : _c.reset();
-                    this.resetProtocolV2Frames(uuid);
-                }
                 Log === null || Log === void 0 ? void 0 : Log.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
                 throw e;
             }
             finally {
-                if (this.isActiveProtocolV2Call(uuid, callToken)) {
-                    if (!completed) {
-                        (_d = this.protocolV2Assemblers.get(uuid)) === null || _d === void 0 ? void 0 : _d.reset();
-                    }
-                    this.resetProtocolV2Frames(uuid);
-                    this.activeProtocolV2Call = null;
-                }
-                if (this.runPromise === runPromise) {
-                    this.runPromise = null;
+                if (highThroughputWrite) {
+                    this.scheduleAndroidBalancedConnectionPriority(uuid);
                 }
             }
         });
     }
+    ensureProtocolV2HighThroughputMtu(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = this.getCachedTransport(uuid);
+            if (!shouldRefreshNegotiatedMtu(transport.mtuSize))
+                return;
+            const refreshedDevice = yield requestNegotiatedMtu(transport.device, 'highThroughput', 1);
+            transport.device = refreshedDevice;
+            transport.mtuSize =
+                typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
+            if (shouldRefreshNegotiatedMtu(transport.mtuSize)) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Protocol V2 high-throughput BLE MTU unavailable: ${String(transport.mtuSize)}`);
+            }
+        });
+    }
+    clearAndroidPriorityResetTimer(uuid) {
+        const timerId = this.androidPriorityResetTimers.get(uuid);
+        if (timerId !== undefined) {
+            clearTimeout(timerId);
+            this.androidPriorityResetTimers.delete(uuid);
+        }
+    }
+    enableAndroidHighConnectionPriority(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (reactNative.Platform.OS !== 'android')
+                return;
+            this.clearAndroidPriorityResetTimer(uuid);
+            if (this.androidHighPriorityDevices.has(uuid))
+                return;
+            const transport = transportCache[uuid];
+            if (!transport)
+                return;
+            try {
+                transport.device = yield transport.device.requestConnectionPriority(reactNativeBlePlx.ConnectionPriority.High);
+                this.androidHighPriorityDevices.add(uuid);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE connection priority changed', {
+                    priority: 'high',
+                });
+            }
+            catch (error) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE high priority request failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+    }
+    scheduleAndroidBalancedConnectionPriority(uuid) {
+        if (reactNative.Platform.OS !== 'android' || !this.androidHighPriorityDevices.has(uuid))
+            return;
+        this.clearAndroidPriorityResetTimer(uuid);
+        const timerId = setTimeout(() => {
+            this.androidPriorityResetTimers.delete(uuid);
+            this.restoreAndroidConnectionPriority(uuid, transportCache[uuid]).catch(error => Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE priority restore failed', error));
+        }, ANDROID_HIGH_PRIORITY_IDLE_MS);
+        this.androidPriorityResetTimers.set(uuid, timerId);
+    }
+    restoreAndroidConnectionPriority(uuid, transport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.clearAndroidPriorityResetTimer(uuid);
+            if (reactNative.Platform.OS !== 'android' || !this.androidHighPriorityDevices.delete(uuid) || !transport) {
+                return;
+            }
+            try {
+                transport.device = yield transport.device.requestConnectionPriority(reactNativeBlePlx.ConnectionPriority.Balanced);
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE connection priority changed', {
+                    priority: 'balanced',
+                });
+            }
+            catch (error) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android BLE balanced priority request failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+    }
+    createProtocolV2Adapter(uuid) {
+        var _a;
+        const generation = (_a = this.monitorTokens.get(uuid)) !== null && _a !== void 0 ? _a : 0;
+        const assertCurrentGeneration = () => {
+            if (this.monitorTokens.get(uuid) !== generation) {
+                throw new Error(`Protocol V2 monitor generation changed for ${uuid}`);
+            }
+        };
+        return {
+            router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
+            maxFrameBytes: transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
+            generation,
+            prepareCall: () => {
+                var _a;
+                assertCurrentGeneration();
+                (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                this.resetProtocolV2Frames(uuid);
+            },
+            writeFrame: (frame, context) => __awaiter(this, void 0, void 0, function* () {
+                assertCurrentGeneration();
+                const currentTransport = this.getCachedTransport(uuid);
+                yield this.writeProtocolV2Frame(uuid, currentTransport, frame, context, assertCurrentGeneration);
+            }),
+            readFrame: () => __awaiter(this, void 0, void 0, function* () {
+                assertCurrentGeneration();
+                const rxFrame = yield this.readProtocolV2Frame(uuid);
+                if (!(rxFrame instanceof Uint8Array)) {
+                    throw new Error('Protocol V2 response is not Uint8Array');
+                }
+                return rxFrame;
+            }),
+            reset: (reason) => {
+                var _a;
+                (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                this.rejectProtocolV2Frames(uuid, new Error(reason));
+            },
+            logger: Log,
+            logPrefix: 'ProtocolV2 RN-BLE',
+            createTimeoutError: (messageName, timeout) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE response timeout after ${timeout}ms for ${messageName}`),
+        };
+    }
     getProtocolType(path) {
-        return this.deviceProtocol.get(path);
+        return this.getActiveProtocol(path);
     }
 }
 
+exports.BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD;
+exports.BLE_CONNECT_TIMEOUT_MS = BLE_CONNECT_TIMEOUT_MS;
+exports.BLE_GATT_SETUP_TIMEOUT_MS = BLE_GATT_SETUP_TIMEOUT_MS;
+exports.BLE_WRITE_PACKET_TIMEOUT_MS = BLE_WRITE_PACKET_TIMEOUT_MS;
+exports.BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD;
+exports.PROTOCOL_REPROBE_FALLBACK_ATTEMPTS = PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
 exports.configureProtocolV2BleTuning = configureProtocolV2BleTuning;
 exports["default"] = ReactNativeBleTransport;
+exports.getFirmwareUploadWriteRetryType = getFirmwareUploadWriteRetryType;
 exports.getProtocolV2BleTuning = getProtocolV2BleTuning;
 exports.resetProtocolV2BleTuning = resetProtocolV2BleTuning;