@onekeyfe/hd-transport-web-device 1.2.0-alpha.17 → 1.2.0-alpha.171

package/dist/index.js

@@ -41,14 +41,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const HIGH_VOLUME_CALLS = new Set(['FileWrite', 'FilesystemFileWrite', 'EmmcFileWrite']);
-function shouldSuppressHighVolumeCallLog(name) {
-    return HIGH_VOLUME_CALLS.has(name);
-}
-function createTransportCallLog(name, protocol) {
-    return { name, protocol };
-}
-
 const { parseConfigure: parseConfigure$1, check: check$1, ProtocolV1: ProtocolV1$1 } = transport__default["default"];
 const CONFIGURATION_ID = 1;
 const INTERFACE_ID = 0;
@@ -59,20 +51,39 @@ const REPORT_ID = transport.PROTOCOL_V1_REPORT_ID;
 const HEADER_LENGTH = transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
-const PROTOCOL_PROBE_TIMEOUT = 1000;
-function inferProtocolHintFromDeviceName$1(name) {
-    return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
+const PROTOCOL_V1_PROBE_TIMEOUT = 5000;
+const PROTOCOL_V2_PROBE_TIMEOUT = 1000;
+const EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS = 2;
+let activeWebUsbTransport;
+let usbDisconnectListenerAttached = false;
+function registerActiveWebUsbTransport(instance, usb) {
+    activeWebUsbTransport = instance;
+    if (usbDisconnectListenerAttached)
+        return;
+    usbDisconnectListenerAttached = true;
+    usb.addEventListener('disconnect', event => {
+        if (!event.device)
+            return;
+        const path = hdShared.resolveOneKeyUsbDevicePath(event.device);
+        if (!path)
+            return;
+        activeWebUsbTransport === null || activeWebUsbTransport === void 0 ? void 0 : activeWebUsbTransport.markProtocolStale(path);
+        activeWebUsbTransport === null || activeWebUsbTransport === void 0 ? void 0 : activeWebUsbTransport.emitDeviceDisconnect(path, event.device);
+    });
 }
-class WebUsbTransport {
+class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     constructor() {
+        super({
+            router: transport.PROTOCOL_V2_CHANNEL_USB,
+            maxFrameBytes: transport.PROTOCOL_V2_FRAME_MAX_BYTES,
+            logPrefix: 'ProtocolV2 WebUSB',
+        });
         this.deviceProtocol = new Map();
         this.deviceProtocolHints = new Map();
-        this.protocolV2Assemblers = new Map();
-        this.protocolV2Sessions = new Map();
-        this.protocolV2ReadTimeouts = new Map();
+        this.staleProtocolPaths = new Set();
+        this.acquiredPaths = new Set();
+        this.probedDeviceObjects = new Map();
         this.deviceEndpoints = new Map();
-        this.mockSerialPaths = new WeakMap();
-        this.mockSerialCounter = 0;
         this.name = 'WebUsbTransport';
         this.stopped = false;
         this.configured = false;
@@ -81,13 +92,27 @@ class WebUsbTransport {
         this.endpointId = ENDPOINT_ID;
         this.interfaceId = INTERFACE_ID;
     }
-    init(logger) {
+    init(logger, emitter) {
         this.Log = logger;
+        this.emitter = emitter;
         const { usb } = navigator;
         if (!usb) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'WebUSB is not supported by current browsers');
         }
         this.usb = usb;
+        registerActiveWebUsbTransport(this, usb);
+    }
+    emitDeviceDisconnect(path, device) {
+        var _a, _b;
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit(transport.TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+            name: (_b = device === null || device === void 0 ? void 0 : device.productName) !== null && _b !== void 0 ? _b : '',
+            id: path,
+            connectId: path,
+        });
+    }
+    markProtocolStale(path) {
+        this.staleProtocolPaths.add(path);
+        this.probedDeviceObjects.delete(path);
     }
     configure(signedData) {
         const messages = parseConfigure$1(signedData);
@@ -95,9 +120,18 @@ class WebUsbTransport {
         this.messages = messages;
     }
     configureProtocolV2(signedData) {
+        var _a;
+        const schemaSource = typeof signedData === 'string'
+            ? signedData
+            : (_a = JSON.stringify(signedData)) !== null && _a !== void 0 ? _a : String(signedData);
+        if (schemaSource === this.protocolV2SchemaSource)
+            return;
+        const hadProtocolV2Schema = this.protocolV2SchemaSource !== undefined;
         this.messagesV2 = parseConfigure$1(signedData);
-        this.protocolV2Sessions.clear();
-        this.protocolV2ReadTimeouts.clear();
+        this.protocolV2SchemaSource = schemaSource;
+        if (!hadProtocolV2Schema)
+            return;
+        this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] schema link cleanup failed:', error); });
     }
     promptDeviceAccess() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -119,20 +153,6 @@ class WebUsbTransport {
             return this.deviceList;
         });
     }
-    getDevicePath(device) {
-        var _a;
-        if (typeof device.serialNumber === 'string' && device.serialNumber.length > 0) {
-            return device.serialNumber;
-        }
-        let path = this.mockSerialPaths.get(device);
-        if (!path) {
-            this.mockSerialCounter += 1;
-            path = `mock-serial:${device.vendorId.toString(16)}:${device.productId.toString(16)}:${this.mockSerialCounter}`;
-            this.mockSerialPaths.set(device, path);
-            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUSB] device has no serial number, using mock path: ${path}`);
-        }
-        return path;
-    }
     getConnectedDevices() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.usb)
@@ -142,41 +162,88 @@ class WebUsbTransport {
                 const isOneKey = hdShared.ONEKEY_WEBUSB_FILTER.some((desc) => dev.vendorId === desc.vendorId && dev.productId === desc.productId);
                 return isOneKey && !hdShared.isKnownTrezorWebUsbDevice(dev);
             });
-            this.deviceList = onekeyDevices.map(device => {
-                const path = this.getDevicePath(device);
-                const protocolHint = inferProtocolHintFromDeviceName$1(device.productName);
+            this.deviceList = onekeyDevices.flatMap(device => {
+                const path = hdShared.resolveOneKeyUsbDevicePath(device);
+                if (!path)
+                    return [];
+                const protocolHint = hdShared.inferProtocolHintFromUsbId(device.vendorId, device.productId);
                 if (protocolHint) {
                     this.deviceProtocolHints.set(path, protocolHint);
                 }
-                return {
-                    path,
-                    device,
-                    commType: 'webusb',
-                };
+                return [
+                    {
+                        path,
+                        device,
+                        commType: 'webusb',
+                    },
+                ];
             });
             return this.deviceList;
         });
     }
     acquire(input) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
             if (!input.path)
                 return;
             try {
+                yield this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
                 yield this.closeOpenDevice(input.path);
                 yield this.connect((_a = input.path) !== null && _a !== void 0 ? _a : '', true);
-                const deviceName = (_b = this.deviceList.find(device => device.path === input.path)) === null || _b === void 0 ? void 0 : _b.device.productName;
-                const protocolHint = input.expectedProtocol
-                    ? undefined
-                    : (_c = this.deviceProtocolHints.get(input.path)) !== null && _c !== void 0 ? _c : inferProtocolHintFromDeviceName$1(deviceName);
-                if (protocolHint) {
-                    this.deviceProtocolHints.set(input.path, protocolHint);
+                if (input.skipProtocolProbe) {
+                    if (!input.expectedProtocol) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'skipProtocolProbe requires an expected protocol');
+                    }
+                    this.staleProtocolPaths.delete(input.path);
+                    this.deviceProtocol.set(input.path, input.expectedProtocol);
+                    const currentDevice = (_b = this.deviceList.find(d => d.path === input.path)) === null || _b === void 0 ? void 0 : _b.device;
+                    if (currentDevice) {
+                        this.probedDeviceObjects.set(input.path, currentDevice);
+                    }
+                }
+                else if (input.forceProtocolDetection) {
+                    this.staleProtocolPaths.delete(input.path);
+                    this.deviceProtocol.delete(input.path);
+                    this.deviceProtocolHints.delete(input.path);
+                }
+                if (!input.skipProtocolProbe && this.staleProtocolPaths.has(input.path)) {
+                    this.staleProtocolPaths.delete(input.path);
+                    this.deviceProtocol.delete(input.path);
                 }
-                yield this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
+                if (!input.skipProtocolProbe && this.deviceProtocol.has(input.path)) {
+                    const currentDevice = (_c = this.deviceList.find(d => d.path === input.path)) === null || _c === void 0 ? void 0 : _c.device;
+                    if (!currentDevice || currentDevice !== this.probedDeviceObjects.get(input.path)) {
+                        this.deviceProtocol.delete(input.path);
+                    }
+                }
+                const cachedProtocol = this.deviceProtocol.get(input.path);
+                if (!input.skipProtocolProbe &&
+                    cachedProtocol &&
+                    input.expectedProtocol &&
+                    cachedProtocol !== input.expectedProtocol) {
+                    this.deviceProtocol.delete(input.path);
+                }
+                if (!this.deviceProtocol.has(input.path)) {
+                    const usbDevice = (_d = this.deviceList.find(device => device.path === input.path)) === null || _d === void 0 ? void 0 : _d.device;
+                    const protocolHint = input.expectedProtocol
+                        ? undefined
+                        : (_f = (_e = input.protocolHint) !== null && _e !== void 0 ? _e : this.deviceProtocolHints.get(input.path)) !== null && _f !== void 0 ? _f : hdShared.inferProtocolHintFromUsbId(usbDevice === null || usbDevice === void 0 ? void 0 : usbDevice.vendorId, usbDevice === null || usbDevice === void 0 ? void 0 : usbDevice.productId);
+                    if (protocolHint) {
+                        this.deviceProtocolHints.set(input.path, protocolHint);
+                    }
+                    yield this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
+                    const probedDevice = (_g = this.deviceList.find(d => d.path === input.path)) === null || _g === void 0 ? void 0 : _g.device;
+                    if (probedDevice) {
+                        this.probedDeviceObjects.set(input.path, probedDevice);
+                    }
+                }
+                this.acquiredPaths.add(input.path);
                 return yield Promise.resolve(input.path);
             }
             catch (e) {
                 this.Log.debug('acquire error: ', e instanceof Error ? `${e.name}: ${e.message}` : String(e));
+                this.acquiredPaths.delete(input.path);
+                yield this.closeOpenDevice(input.path);
                 throw e;
             }
         });
@@ -184,29 +251,53 @@ class WebUsbTransport {
     createProtocolMismatchError(expected) {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
     }
+    createProtocolProbeTimeoutError(expected, attempts) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed, `Protocol ${expected} probe timeout after ${attempts} attempts`);
+    }
     createProtocolDetectionError() {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
     }
     detectProtocol(path, expectedProtocol, protocolHint) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (expectedProtocol === 'V1') {
                 if (yield this.probeProtocolV1(path)) {
                     this.deviceProtocol.set(path, 'V1');
                     return 'V1';
                 }
+                yield this.closeConnectionAfterProbe(path);
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
             if (expectedProtocol === 'V2') {
-                this.deviceProtocol.set(path, 'V2');
-                return 'V2';
+                for (let attempt = 1; attempt <= EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS; attempt += 1) {
+                    if (yield this.probeProtocolV2(path)) {
+                        this.deviceProtocol.set(path, 'V2');
+                        return 'V2';
+                    }
+                    if (attempt < EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS) {
+                        yield this.resetConnectionAfterProbe(path);
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUsbTransport] Protocol V2 probe timed out, retrying ${attempt + 1}/${EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS}`);
+                    }
+                    else {
+                        yield this.closeConnectionAfterProbe(path);
+                    }
+                }
+                this.deviceProtocol.delete(path);
+                throw this.createProtocolProbeTimeoutError(expectedProtocol, EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS);
             }
             const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(path) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
-            for (const protocol of probeOrder) {
+            for (const [index, protocol] of probeOrder.entries()) {
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(path) : yield this.probeProtocolV2(path);
                 if (detected) {
                     this.deviceProtocol.set(path, protocol);
                     return protocol;
                 }
+                if (index < probeOrder.length - 1) {
+                    yield this.resetConnectionAfterProbe(path);
+                }
+                else {
+                    yield this.closeConnectionAfterProbe(path);
+                }
             }
             this.deviceProtocol.delete(path);
             throw this.createProtocolDetectionError();
@@ -273,7 +364,7 @@ class WebUsbTransport {
         };
     }
     connectToDevice(path, first) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let device = yield this.findDevice(path);
             if (!device.opened) {
@@ -297,33 +388,30 @@ class WebUsbTransport {
             }
             const endpoints = this.discoverEndpoints(device);
             this.deviceEndpoints.set(path, endpoints);
-            (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
-            this.protocolV2Assemblers.set(path, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES));
             yield device.claimInterface(endpoints.interfaceNumber);
             yield this.clearEndpointHalt(device, 'in', endpoints.endpointIn);
             yield this.clearEndpointHalt(device, 'out', endpoints.endpointOut);
         });
     }
     closeOpenDevice(path) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            const current = (_b = this.deviceList.find(device => device.path === path)) === null || _b === void 0 ? void 0 : _b.device;
+            const current = (_a = this.deviceList.find(device => device.path === path)) === null || _a === void 0 ? void 0 : _a.device;
             if (!(current === null || current === void 0 ? void 0 : current.opened))
                 return;
             const endpoints = this.deviceEndpoints.get(path);
-            const ifaceNum = (_c = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _c !== void 0 ? _c : this.interfaceId;
+            const ifaceNum = (_b = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _b !== void 0 ? _b : this.interfaceId;
             try {
                 yield current.releaseInterface(ifaceNum);
             }
             catch (error) {
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
             }
             try {
                 yield current.close();
             }
             catch (error) {
-                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug('[WebUsbTransport] close before reconnect failed:', error);
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] close before reconnect failed:', error);
             }
         });
     }
@@ -338,8 +426,18 @@ class WebUsbTransport {
             }
         });
     }
+    assertAcquired(path) {
+        if (!this.acquiredPaths.has(path)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device is not acquired for ${path}`);
+        }
+    }
     post(session, name, data) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertAcquired(session);
+            if (this.deviceProtocol.get(session) === 'V2') {
+                yield this.sendProtocolV2UsbFlowControl(session, name, data);
+                return;
+            }
             yield this.call(session, name, data);
         });
     }
@@ -368,6 +466,7 @@ class WebUsbTransport {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.Log.debug(`[WebUsbTransport] transfer${direction} failed, retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(error)}`);
+            this.staleProtocolPaths.add(path);
             yield hdShared.wait(attempt * PACKET_IO_RETRY_DELAY);
             try {
                 const currentDevice = yield this.findDevice(path);
@@ -485,34 +584,33 @@ class WebUsbTransport {
             throw lastError;
         });
     }
-    resetConnectionAfterProbe(path) {
-        var _a, _b;
+    transferInOnce(path, length) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            this.protocolV2Sessions.delete(path);
-            this.protocolV2ReadTimeouts.delete(path);
-            try {
-                const device = yield this.findDevice(path);
-                if (device.opened) {
-                    const endpoints = this.deviceEndpoints.get(path);
-                    const ifaceNum = (_b = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _b !== void 0 ? _b : this.interfaceId;
-                    try {
-                        yield device.releaseInterface(ifaceNum);
-                    }
-                    catch (error) {
-                        this.Log.debug('[WebUsbTransport] releaseInterface after protocol probe error:', error);
-                    }
-                    yield device.close();
-                }
-            }
-            catch (error) {
-                this.Log.debug('[WebUsbTransport] close after protocol probe error:', error);
+            const device = yield this.findDevice(path);
+            if (!device.opened) {
+                throw new Error('USBDevice is not open for transferIn');
             }
+            const endpoints = this.deviceEndpoints.get(path);
+            const endpointIn = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointIn) !== null && _a !== void 0 ? _a : this.endpointId;
+            const result = yield device.transferIn(endpointIn, length);
+            return this.getTransferInData(result);
+        });
+    }
+    closeConnectionAfterProbe(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.rotateProtocolV2UsbGeneration(path, 'WebUSB protocol probe reset');
+            yield this.closeOpenDevice(path);
+        });
+    }
+    resetConnectionAfterProbe(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.closeConnectionAfterProbe(path);
             yield this.getConnectedDevices();
             yield this.connect(path, false);
         });
     }
-    withProtocolReadTimeout(_path, promise, timeoutMs, protocol, onTimeout) {
+    withProtocolReadTimeout(path, promise, timeoutMs, protocol, onTimeout) {
         return __awaiter(this, void 0, void 0, function* () {
             let timer;
             let timedOut = false;
@@ -527,11 +625,19 @@ class WebUsbTransport {
                 return yield Promise.race([
                     guardedPromise,
                     new Promise((_, reject) => {
-                        timer = setTimeout(() => {
+                        timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
                             timedOut = true;
                             onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout();
+                            if (protocol === 'V1') {
+                                try {
+                                    yield this.resetConnectionAfterProbe(path);
+                                }
+                                catch (error) {
+                                    this.Log.debug('[WebUsbTransport] reset after Protocol V1 timeout failed:', error);
+                                }
+                            }
                             reject(new Error(`Protocol ${protocol} read timeout after ${timeoutMs}ms`));
-                        }, timeoutMs);
+                        }), timeoutMs);
                     }),
                 ]);
             }
@@ -547,7 +653,9 @@ class WebUsbTransport {
                 return false;
             }
             try {
-                yield this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
+                yield this.callProtocolV1(path, 'Initialize', {}, {
+                    timeoutMs: PROTOCOL_V1_PROBE_TIMEOUT,
+                });
                 return true;
             }
             catch (_error) {
@@ -562,10 +670,9 @@ class WebUsbTransport {
             }
             return transport.probeProtocolV2({
                 call: (name, data, options) => this.callProtocolV2(path, name, data, options),
-                timeoutMs: PROTOCOL_PROBE_TIMEOUT,
+                timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT,
                 logger: this.Log,
                 logPrefix: 'ProtocolV2 WebUSB',
-                onProbeFailed: () => this.resetConnectionAfterProbe(path),
             });
         });
     }
@@ -574,6 +681,7 @@ class WebUsbTransport {
             if (this.messages == null) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
+            this.assertAcquired(path);
             const device = yield this.findDevice(path);
             if (!device) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
@@ -582,9 +690,6 @@ class WebUsbTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${path}`);
             }
-            if (!shouldSuppressHighVolumeCallLog(name)) {
-                this.Log.debug('transport call', createTransportCallLog(name, protocol));
-            }
             if (protocol === 'V2') {
                 return this.callProtocolV2(path, name, data, options);
             }
@@ -613,79 +718,8 @@ class WebUsbTransport {
         });
     }
     callProtocolV2(path, name, data, options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const protocolV1Messages = this.messages;
-            if (!this.messagesV2) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Protocol V2 schema not configured');
-            }
-            if (!protocolV1Messages) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
-            }
-            let session = this.protocolV2Sessions.get(path);
-            if (!session) {
-                session = new transport.ProtocolV2Session({
-                    schemas: {
-                        protocolV1: protocolV1Messages,
-                        protocolV2: this.messagesV2,
-                    },
-                    router: transport.PROTOCOL_V2_CHANNEL_USB,
-                    writeFrame: (frame) => this.transferOutOnce(path, frame),
-                    readFrame: () => this.receiveProtocolV2Frame(path, this.protocolV2ReadTimeouts.get(path)),
-                    logger: this.Log,
-                    logPrefix: 'ProtocolV2 WebUSB',
-                    createTimeoutError: (messageName, timeoutMs) => new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${messageName}`),
-                });
-                this.protocolV2Sessions.set(path, session);
-            }
-            this.protocolV2ReadTimeouts.set(path, options === null || options === void 0 ? void 0 : options.timeoutMs);
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            try {
-                return yield session.call(name, data, options);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-                if (message.includes('protocol v2 read timeout') || message.includes('response timeout')) {
-                    try {
-                        yield this.resetConnectionAfterProbe(path);
-                    }
-                    catch (resetError) {
-                        this.Log.debug('[WebUsbTransport] Protocol V2 timeout reset failed:', resetError);
-                    }
-                }
-                throw error;
-            }
-            finally {
-                this.protocolV2ReadTimeouts.delete(path);
-            }
-        });
-    }
-    receiveProtocolV2Frame(path, timeoutMs) {
         return __awaiter(this, void 0, void 0, function* () {
-            let assembler = this.protocolV2Assemblers.get(path);
-            if (!assembler) {
-                assembler = new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES);
-                this.protocolV2Assemblers.set(path, assembler);
-            }
-            let frame = assembler.push(new Uint8Array(0));
-            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
-            while (!frame) {
-                const cancelToken = { cancelled: false };
-                const transferIn = this.transferInWithRetry(path, transport.PROTOCOL_V2_FRAME_MAX_BYTES, cancelToken);
-                const dataView = deadline
-                    ? yield this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V2', () => {
-                        cancelToken.cancelled = true;
-                    })
-                    : yield transferIn;
-                const bytes = new Uint8Array(this.toArrayBuffer(dataView.buffer.slice(dataView.byteOffset, dataView.byteOffset + dataView.byteLength)));
-                try {
-                    frame = assembler.push(bytes);
-                }
-                catch (error) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, error instanceof Error ? error.message : String(error));
-                }
-            }
-            return frame;
+            return this.callProtocolV2Usb(path, name, data, options);
         });
     }
     receiveData(path, timeoutMs) {
@@ -726,45 +760,81 @@ class WebUsbTransport {
         });
     }
     release(path) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const device = yield this.findDevice(path);
-            const endpoints = this.deviceEndpoints.get(path);
-            const ifaceNum = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _a !== void 0 ? _a : this.interfaceId;
-            yield device.releaseInterface(ifaceNum);
-            yield device.close();
-            this.deviceProtocol.delete(path);
-            this.deviceProtocolHints.delete(path);
-            (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
-            this.protocolV2Assemblers.delete(path);
-            this.protocolV2Sessions.delete(path);
-            this.protocolV2ReadTimeouts.delete(path);
+            this.acquiredPaths.delete(path);
+            yield this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
+            yield this.closeOpenDevice(path);
             this.deviceEndpoints.delete(path);
         });
     }
+    getProtocolV2UsbSchemas() {
+        if (!this.messages || !this.messagesV2) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+        }
+        return {
+            protocolV1: this.messages,
+            protocolV2: this.messagesV2,
+        };
+    }
+    getProtocolV2UsbLogger() {
+        return this.Log;
+    }
+    writeProtocolV2UsbPacket(path, frame, _context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transferOutOnce(path, frame);
+        });
+    }
+    readProtocolV2UsbPacket(path, _context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataView = yield this.transferInOnce(path, transport.PROTOCOL_V2_FRAME_MAX_BYTES);
+            return new Uint8Array(this.toArrayBuffer(dataView.buffer.slice(dataView.byteOffset, dataView.byteOffset + dataView.byteLength)));
+        });
+    }
+    resetProtocolV2UsbNativeLink(path, _reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.closeOpenDevice(path);
+        });
+    }
+    onProtocolV2UsbLinkInvalidated(path, reason) {
+        var _a;
+        this.deviceProtocol.delete(path);
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUsbTransport] Protocol V2 link invalidated: ${path}`, reason);
+    }
+    createProtocolV2UsbTimeoutError(name, timeoutMs) {
+        return new transport.ProtocolV2LinkError('response-timeout', `Protocol V2 response timeout after ${timeoutMs}ms for ${name}`);
+    }
     getProtocolType(path) {
         return this.deviceProtocol.get(path);
     }
 }
 
-const { parseConfigure, ProtocolV1, check } = transport__default["default"];
-function inferProtocolHintFromDeviceName(name) {
-    return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
+const BLE_ATT_HEADER_BYTES = 3;
+function resolveBlePacketCapacity(mtu, maximumPacketCapacity, fallbackPacketCapacity) {
+    if (typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= BLE_ATT_HEADER_BYTES) {
+        return fallbackPacketCapacity;
+    }
+    return Math.min(maximumPacketCapacity, Math.floor(mtu) - BLE_ATT_HEADER_BYTES);
 }
+
+const { parseConfigure, ProtocolV1, check } = transport__default["default"];
 const toBleDescriptor = (device, protocolType) => (Object.assign({ id: device.id, name: device.name, path: device.id, debug: false, commType: 'electron-ble' }, (protocolType ? { protocolType } : {})));
-const BLE_PACKET_SIZE = 192;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAXIMUM = 244;
 const BLE_WRITE_DELAY_MS = 5;
-const BLE_RESPONSE_TIMEOUT_MS = 30000;
-const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
+const PROTOCOL_PROBE_TIMEOUT_MS = 3000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
 class ElectronBleTransport {
     constructor() {
         this.name = 'ElectronBleTransport';
         this.configured = false;
         this.runPromise = null;
+        this.runPromiseDeviceId = null;
         this.connectedDevices = new Set();
         this.deviceProtocol = new Map();
         this.deviceProtocolHints = new Map();
+        this.confirmedProtocolV2 = new Set();
+        this.deviceMtus = new Map();
+        this.devicePacketCapacities = new Map();
         this.v1Buffers = new Map();
         this.v2Assemblers = new Map();
         this.v2FrameQueues = new Map();
@@ -786,12 +856,13 @@ class ElectronBleTransport {
                 this.rejectProtocolV2Frames(uuid, new Error(reason));
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Electron BLE] Protocol V2 link invalidated:', uuid, reason);
                 if (reason.startsWith('Protocol V2 link-fatal error:')) {
-                    yield this.release(uuid);
+                    yield this.releaseNative(uuid);
                 }
             }),
         });
+        this.warnedMissingRelease = false;
         this.notificationCleanups = new Map();
-        this.disconnectCleanups = new Map();
+        this.mtuCleanups = new Map();
         this.notificationTokens = new Map();
         this.nextNotificationToken = 1;
     }
@@ -830,19 +901,26 @@ class ElectronBleTransport {
             .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] link cleanup failed:', error); });
         this.connectedDevices.delete(deviceId);
         this.deviceProtocol.delete(deviceId);
+        this.deviceMtus.delete(deviceId);
+        this.devicePacketCapacities.delete(deviceId);
         this.v1Buffers.delete(deviceId);
         this.v2Assemblers.delete(deviceId);
         this.resetProtocolV2Frames(deviceId);
         this.notificationTokens.delete(deviceId);
+        if (this.runPromise && this.runPromiseDeviceId === deviceId) {
+            this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
+            this.runPromise = null;
+            this.runPromiseDeviceId = null;
+        }
         const notifyCleanup = this.notificationCleanups.get(deviceId);
         if (notifyCleanup) {
             notifyCleanup();
             this.notificationCleanups.delete(deviceId);
         }
-        const disconnectCleanup = this.disconnectCleanups.get(deviceId);
-        if (disconnectCleanup) {
-            disconnectCleanup();
-            this.disconnectCleanups.delete(deviceId);
+        const mtuCleanup = this.mtuCleanups.get(deviceId);
+        if (mtuCleanup) {
+            mtuCleanup();
+            this.mtuCleanups.delete(deviceId);
         }
     }
     init(logger, emitter) {
@@ -852,17 +930,43 @@ class ElectronBleTransport {
         if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble BLE API is not available. Please ensure you are running in Electron with Noble support.');
         }
+        this.subscribeHostDisconnects();
         (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Electron BLE] Transport initialized');
     }
+    subscribeHostDisconnects() {
+        var _a, _b, _c;
+        (_a = this.hostDisconnectCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.hostDisconnectCleanup = (_c = (_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.nobleBle) === null || _c === void 0 ? void 0 : _c.onDeviceDisconnected((disconnectedDevice) => {
+            var _a, _b, _c;
+            const uuid = disconnectedDevice === null || disconnectedDevice === void 0 ? void 0 : disconnectedDevice.id;
+            if (!uuid)
+                return;
+            this.cleanupDeviceState(uuid);
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Device link dropped:', uuid, (_b = disconnectedDevice.reason) !== null && _b !== void 0 ? _b : hdShared.EBleDisconnectReason.DeviceDisconnected);
+            (_c = this.emitter) === null || _c === void 0 ? void 0 : _c.emit(transport.TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+                name: disconnectedDevice.name,
+                id: uuid,
+                connectId: uuid,
+            });
+        });
+    }
     configure(signedData) {
         this._messages = parseConfigure(signedData);
         this.configured = true;
     }
     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);
-        this.protocolV2Links
-            .invalidateAllLinks('Protocol V2 schema reconfigured')
-            .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] schema link cleanup failed:', error); });
+        this.protocolV2SchemaConfiguration = configuration;
+        if (isReconfiguration) {
+            this.protocolV2Links
+                .invalidateAllLinks('Protocol V2 schema reconfigured')
+                .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] schema link cleanup failed:', error); });
+        }
     }
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -880,10 +984,6 @@ class ElectronBleTransport {
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Electron BLE] enumerate found ${devices.length} device(s):`);
                 for (const dev of devices) {
                     (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Electron BLE]   id="${dev.id}" name="${dev.name}"`);
-                    const protocolHint = inferProtocolHintFromDeviceName(dev.name);
-                    if (protocolHint) {
-                        this.deviceProtocolHints.set(dev.id, protocolHint);
-                    }
                 }
                 return devices.map(device => toBleDescriptor(device));
             }
@@ -894,7 +994,7 @@ class ElectronBleTransport {
         });
     }
     acquire(input) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
             const { uuid, forceCleanRunPromise, expectedProtocol } = input;
             if (!uuid) {
@@ -906,8 +1006,8 @@ class ElectronBleTransport {
             if (forceCleanRunPromise && this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
-                this.rejectAllProtocolV2Frames(error);
                 this.runPromise = null;
+                this.runPromiseDeviceId = null;
             }
             try {
                 if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
@@ -919,7 +1019,7 @@ class ElectronBleTransport {
                 }
                 const protocolHint = expectedProtocol
                     ? undefined
-                    : (_b = this.deviceProtocolHints.get(uuid)) !== null && _b !== void 0 ? _b : inferProtocolHintFromDeviceName(device.name);
+                    : (_b = input.protocolHint) !== null && _b !== void 0 ? _b : this.deviceProtocolHints.get(uuid);
                 if (protocolHint) {
                     this.deviceProtocolHints.set(uuid, protocolHint);
                 }
@@ -930,52 +1030,64 @@ class ElectronBleTransport {
                 catch (error) {
                     this.handleBluetoothError(error);
                 }
+                const mtuCleanup = this.createMtuSubscription(uuid);
+                if (mtuCleanup) {
+                    this.mtuCleanups.set(uuid, mtuCleanup);
+                }
                 this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
-                this.v2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler());
+                this.v2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
                 yield window.desktopApi.nobleBle.subscribe(uuid);
+                yield this.refreshBlePacketCapacity(uuid);
                 const cleanup = this.createNotificationSubscription(uuid);
                 this.notificationCleanups.set(uuid, cleanup);
-                const disconnectCleanup = window.desktopApi.nobleBle.onDeviceDisconnected((disconnectedDevice) => {
-                    var _a;
-                    if (disconnectedDevice.id === uuid) {
-                        this.cleanupDeviceState(uuid);
-                        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit('device-disconnect', {
-                            name: disconnectedDevice.name,
-                            id: disconnectedDevice.id,
-                            connectId: disconnectedDevice.id,
-                        });
-                    }
-                });
-                this.disconnectCleanups.set(uuid, disconnectCleanup);
                 const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint);
-                (_c = this.emitter) === null || _c === void 0 ? void 0 : _c.emit('device-connect', {
-                    name: device.name,
-                    id: device.id,
-                    connectId: device.id,
-                });
+                if (protocolType === 'V2') {
+                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Electron BLE] Protocol V2 write configured', {
+                        writeMode: 'withoutResponse',
+                        negotiatedMtu: this.deviceMtus.get(uuid),
+                        packetCapacity: (_d = this.devicePacketCapacities.get(uuid)) !== null && _d !== void 0 ? _d : BLE_PACKET_SIZE_FALLBACK,
+                    });
+                }
                 return Object.assign(Object.assign({}, toBleDescriptor({ id: device.id, name: device.name }, protocolType)), { uuid });
             }
             catch (error) {
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] acquire failed:', error);
+                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.error('[Electron BLE] acquire failed:', error);
                 try {
-                    if (((_e = window.desktopApi) === null || _e === void 0 ? void 0 : _e.nobleBle) && this.connectedDevices.has(uuid)) {
+                    if (((_f = window.desktopApi) === null || _f === void 0 ? void 0 : _f.nobleBle) && this.connectedDevices.has(uuid)) {
                         yield window.desktopApi.nobleBle.unsubscribe(uuid);
                         yield window.desktopApi.nobleBle.disconnect(uuid);
                     }
                 }
                 catch (cleanupError) {
-                    (_f = this.Log) === null || _f === void 0 ? void 0 : _f.debug('[Electron BLE] acquire cleanup failed:', cleanupError);
+                    (_g = this.Log) === null || _g === void 0 ? void 0 : _g.debug('[Electron BLE] acquire cleanup failed:', cleanupError);
                 }
                 this.cleanupDeviceState(uuid);
                 throw error;
             }
         });
     }
-    release(id) {
-        var _a, _b;
+    release(id, _onclose, keepSession) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield this.protocolV2Links.invalidateLink(id, 'Electron BLE transport released');
+                yield this.releaseLogical(id, keepSession);
+            }
+            catch (error) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.error('[Electron BLE] release failed:', error);
+                this.cleanupDeviceState(id);
+            }
+        });
+    }
+    disconnect(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.releaseNative(id);
+        });
+    }
+    releaseNative(id) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
                 if (this.connectedDevices.has(id)) {
                     if ((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) {
                         yield window.desktopApi.nobleBle.unsubscribe(id);
@@ -990,11 +1102,36 @@ class ElectronBleTransport {
             }
         });
     }
-    createProtocolMismatchError(expected) {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    releaseLogical(id, keepSession) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.connectedDevices.has(id))
+                    return;
+                this.cleanupDeviceState(id);
+                const release = (_b = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) === null || _b === void 0 ? void 0 : _b.release;
+                if (!release) {
+                    if (!this.warnedMissingRelease) {
+                        this.warnedMissingRelease = true;
+                        (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Electron BLE] desktopApi.nobleBle.release is missing from the preload bridge; ' +
+                            'keep-alive idle countdown will never start — map NOBLE_BLE_RELEASE in the desktop preload');
+                    }
+                    return;
+                }
+                yield release(id, keepSession);
+            }
+            catch (error) {
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] logical release failed:', error);
+                this.cleanupDeviceState(id);
+            }
+        });
+    }
+    createProtocolMismatchError(expected, uuid) {
+        const isStaleV2Bond = expected === 'V2' && this.confirmedProtocolV2.has(uuid);
+        return hdShared.ERRORS.TypedError(isStaleV2Bond ? hdShared.HardwareErrorCode.BleDeviceBondError : 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.deviceProtocol.get(uuid) === protocol) {
@@ -1010,12 +1147,16 @@ class ElectronBleTransport {
                     (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V1 (expected)`);
                     return 'V1';
                 }
-                throw this.createProtocolMismatchError(expectedProtocol);
+                throw this.createProtocolMismatchError(expectedProtocol, uuid);
             }
             if (expectedProtocol === 'V2') {
-                this.deviceProtocol.set(uuid, 'V2');
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
-                return 'V2';
+                if (yield this.probeProtocolV2(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V2');
+                    this.confirmedProtocolV2.add(uuid);
+                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+                    return 'V2';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol, uuid);
             }
             const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
             for (let i = 0; i < probeOrder.length; i += 1) {
@@ -1026,6 +1167,9 @@ class ElectronBleTransport {
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
                 if (detected) {
                     this.deviceProtocol.set(uuid, protocol);
+                    if (protocol === 'V2') {
+                        this.confirmedProtocolV2.add(uuid);
+                    }
                     (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> ${protocol}`);
                     return protocol;
                 }
@@ -1049,38 +1193,22 @@ class ElectronBleTransport {
         });
     }
     resetProbeStateAfterProtocolProbe(uuid, protocol) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.protocolV2Links.invalidateLink(uuid, `Reset notify state after Protocol ${protocol} probe`);
             this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
             (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             this.resetProtocolV2Frames(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.runPromiseDeviceId = null;
             }
-            const notifyCleanup = this.notificationCleanups.get(uuid);
-            if (notifyCleanup) {
-                notifyCleanup();
-                this.notificationCleanups.delete(uuid);
-            }
-            this.notificationTokens.delete(uuid);
-            try {
-                yield ((_c = (_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.nobleBle) === null || _c === void 0 ? void 0 : _c.unsubscribe(uuid));
-            }
-            catch (error) {
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug(`[Electron BLE] unsubscribe after Protocol ${protocol} probe failed:`, error);
-            }
-            try {
-                yield ((_f = (_e = window.desktopApi) === null || _e === void 0 ? void 0 : _e.nobleBle) === null || _f === void 0 ? void 0 : _f.subscribe(uuid));
-            }
-            catch (error) {
-                (_g = this.Log) === null || _g === void 0 ? void 0 : _g.debug(`[Electron BLE] resubscribe after Protocol ${protocol} probe failed:`, error);
-                throw error;
+            if (!this.notificationCleanups.has(uuid)) {
+                const cleanup = this.createNotificationSubscription(uuid);
+                this.notificationCleanups.set(uuid, cleanup);
             }
-            const cleanup = this.createNotificationSubscription(uuid);
-            this.notificationCleanups.set(uuid, cleanup);
         });
     }
     probeProtocolV1(uuid) {
@@ -1091,12 +1219,12 @@ class ElectronBleTransport {
             }
             try {
                 this.deviceProtocol.set(uuid, 'V1');
-                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+                yield this.callProtocolV1(uuid, 'GetFeatures', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
                 return true;
             }
             catch (error) {
                 this.clearProbeProtocol(uuid, 'V1');
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Protocol V1 Initialize probe failed:', error);
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Protocol V1 GetFeatures probe failed:', error);
                 return false;
             }
         });
@@ -1126,25 +1254,6 @@ class ElectronBleTransport {
             return detected;
         });
     }
-    writeWithChunking(uuid, hexData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const totalBytes = hexData.length / 2;
-            if (totalBytes <= BLE_PACKET_SIZE) {
-                yield hdShared.wait(BLE_WRITE_DELAY_MS);
-                yield this.writeOnce(uuid, hexData);
-                return;
-            }
-            for (let offset = 0; offset < hexData.length;) {
-                const chunkHexLen = Math.min(BLE_PACKET_SIZE * 2, hexData.length - offset);
-                const chunkHex = hexData.substring(offset, offset + chunkHexLen);
-                offset += chunkHexLen;
-                yield this.writeOnce(uuid, chunkHex);
-                if (offset < hexData.length) {
-                    yield hdShared.wait(BLE_WRITE_DELAY_MS);
-                }
-            }
-        });
-    }
     writeOnce(uuid, hexData) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1152,7 +1261,51 @@ class ElectronBleTransport {
             if (!nobleBle) {
                 throw new Error('Noble BLE API not available');
             }
-            yield nobleBle.write(uuid, hexData);
+            yield nobleBle.write(uuid, hexData, { pacingDelayMs: 0 });
+        });
+    }
+    refreshBlePacketCapacity(uuid) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield ((_b = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) === null || _b === void 0 ? void 0 : _b.getDevice(uuid));
+            this.updateBlePacketCapacity(uuid, device === null || device === void 0 ? void 0 : device.mtu);
+        });
+    }
+    updateBlePacketCapacity(uuid, mtu) {
+        const packetCapacity = resolveBlePacketCapacity(mtu, BLE_PACKET_SIZE_MAXIMUM, BLE_PACKET_SIZE_FALLBACK);
+        if (typeof mtu === 'number') {
+            this.deviceMtus.set(uuid, mtu);
+        }
+        else {
+            this.deviceMtus.delete(uuid);
+        }
+        this.devicePacketCapacities.set(uuid, packetCapacity);
+    }
+    createMtuSubscription(uuid) {
+        var _a, _b;
+        const onMtuChanged = (_b = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) === null || _b === void 0 ? void 0 : _b.onMtuChanged;
+        if (!onMtuChanged)
+            return undefined;
+        return onMtuChanged(device => {
+            if (device.id === uuid) {
+                this.updateBlePacketCapacity(uuid, device.mtu);
+            }
+        });
+    }
+    writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration) {
+        var _a;
+        const packetCapacity = (_a = this.devicePacketCapacities.get(uuid)) !== null && _a !== void 0 ? _a : BLE_PACKET_SIZE_FALLBACK;
+        const shouldPace = !context.highThroughput;
+        return transport.writeProtocolV2BleFrame({
+            frame,
+            packetCapacity,
+            assertActive: assertCurrentGeneration,
+            signal: context.signal,
+            abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+            initialDelayMs: shouldPace && frame.length <= packetCapacity ? BLE_WRITE_DELAY_MS : 0,
+            burstSize: shouldPace ? 1 : undefined,
+            burstPauseMs: shouldPace ? BLE_WRITE_DELAY_MS : 0,
+            writePacket: packet => this.writeOnce(uuid, transport.bytesToHex(packet)),
         });
     }
     handleNotification(deviceId, hexData) {
@@ -1163,7 +1316,7 @@ class ElectronBleTransport {
             if (this.deviceProtocol.get(deviceId) === 'V2') {
                 this.rejectProtocolV2Frames(deviceId, error);
             }
-            else if (this.runPromise) {
+            else if (this.runPromise && this.runPromiseDeviceId === deviceId) {
                 this.runPromise.reject(error);
             }
             return;
@@ -1215,16 +1368,8 @@ class ElectronBleTransport {
         }
         this.getProtocolV2FrameQueue(uuid).push(frame);
     }
-    rejectAllProtocolV2Frames(error) {
-        this.v2FrameQueues.clear();
-        for (const framePromise of this.v2FramePromises.values()) {
-            framePromise.reject(error);
-        }
-        this.v2FramePromises.clear();
-    }
     resetProtocolV2Frames(uuid) {
-        this.v2FrameQueues.delete(uuid);
-        this.v2FramePromises.delete(uuid);
+        this.rejectProtocolV2Frames(uuid, new Error(`Protocol V2 frame state reset for ${uuid}`));
     }
     rejectProtocolV2Frames(uuid, error) {
         this.v2FrameQueues.delete(uuid);
@@ -1257,17 +1402,19 @@ class ElectronBleTransport {
         const result = this.processProtocolV1Notification(deviceId, hexData);
         if (result.error) {
             (_a = this.Log) === null || _a === void 0 ? void 0 : _a.error('[Electron BLE] Protocol V1 packet processing error:', result.error);
-            if (this.runPromise) {
+            if (this.runPromise && this.runPromiseDeviceId === deviceId) {
                 this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError));
             }
             return;
         }
-        if (result.isComplete && result.completePacket && this.runPromise) {
+        if (result.isComplete &&
+            result.completePacket &&
+            this.runPromise &&
+            this.runPromiseDeviceId === deviceId) {
             this.runPromise.resolve(result.completePacket);
         }
     }
     call(uuid, name, data, options) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
@@ -1279,15 +1426,21 @@ class ElectronBleTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
-            if (!shouldSuppressHighVolumeCallLog(name)) {
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('transport call', createTransportCallLog(name, protocol));
-            }
             if (protocol === 'V2') {
                 return this.callProtocolV2(uuid, name, data, options);
             }
             return this.callProtocolV1(uuid, name, data, options);
         });
     }
+    post(uuid, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.deviceProtocol.get(uuid) === 'V2') {
+                yield this.protocolV2Links.sendFlowControl(uuid, () => this.createProtocolV2Adapter(uuid), name, data);
+                return;
+            }
+            yield this.callProtocolV1(uuid, name, data);
+        });
+    }
     callProtocolV1(uuid, name, data, options) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -1301,6 +1454,7 @@ class ElectronBleTransport {
             const runPromise = hdShared.createDeferred();
             runPromise.promise.catch(() => undefined);
             this.runPromise = runPromise;
+            this.runPromiseDeviceId = uuid;
             const messages = this._messages;
             const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
             let timeout;
@@ -1339,6 +1493,17 @@ class ElectronBleTransport {
             }
             catch (e) {
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Electron BLE] Protocol V1 call error:', e);
+                const isProbeTimeout = name === 'GetFeatures' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS;
+                if ((e === null || e === void 0 ? void 0 : e.errorCode) === hdShared.HardwareErrorCode.BleTimeoutError) {
+                    this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
+                    const notifyCleanup = this.notificationCleanups.get(uuid);
+                    notifyCleanup === null || notifyCleanup === void 0 ? void 0 : notifyCleanup();
+                    this.notificationCleanups.delete(uuid);
+                    this.notificationTokens.delete(uuid);
+                    if (!isProbeTimeout) {
+                        yield this.releaseNative(uuid);
+                    }
+                }
                 throw e;
             }
             finally {
@@ -1346,22 +1511,23 @@ class ElectronBleTransport {
                     clearTimeout(timeout);
                 if (this.runPromise === runPromise) {
                     this.runPromise = null;
+                    this.runPromiseDeviceId = null;
                 }
             }
         });
     }
     callProtocolV2(uuid, name, data, options) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const callOptions = Object.assign(Object.assign({}, options), { timeoutMs: (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : BLE_RESPONSE_TIMEOUT_MS });
+            const callOptions = options;
             try {
                 return yield this.protocolV2Links.call(uuid, () => this.createProtocolV2Adapter(uuid), name, data, callOptions);
             }
             catch (e) {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Electron BLE] Protocol V2 call error:', e);
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.error('[Electron BLE] Protocol V2 call error:', e);
                 throw e;
             }
         });
@@ -1376,6 +1542,7 @@ class ElectronBleTransport {
         };
         return {
             router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
+            maxFrameBytes: transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
             generation,
             prepareCall: () => {
                 var _a;
@@ -1383,10 +1550,7 @@ class ElectronBleTransport {
                 (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
                 this.resetProtocolV2Frames(uuid);
             },
-            writeFrame: (frame) => {
-                assertCurrentGeneration();
-                return this.writeWithChunking(uuid, transport.bytesToHex(frame));
-            },
+            writeFrame: (frame, context) => this.writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration),
             readFrame: () => __awaiter(this, void 0, void 0, function* () {
                 assertCurrentGeneration();
                 const rxFrame = yield this.readProtocolV2Frame(uuid);
@@ -1406,6 +1570,7 @@ class ElectronBleTransport {
         };
     }
     processProtocolV1Notification(deviceId, hexData) {
+        var _a;
         try {
             if (typeof hexData !== 'string') {
                 return { isComplete: false, error: 'Invalid hexData type' };
@@ -1424,6 +1589,10 @@ class ElectronBleTransport {
                 bufferState.buffer = [...data.subarray(3)];
             }
             else {
+                if (bufferState.buffer.length === 0) {
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Orphan continuation chunk discarded');
+                    return { isComplete: false };
+                }
                 bufferState.buffer = bufferState.buffer.concat([...data]);
             }
             if (bufferState.buffer.length - transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE >= bufferState.bufferLength) {