@onekeyfe/hd-transport-web-device 1.2.8-alpha.10 → 1.2.8-alpha.101

package/dist/index.js

@@ -51,11 +51,15 @@ 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 USB_DEVICE_IN_USE = 'USB device is already in use';
 const PROTOCOL_V1_PROBE_TIMEOUT = 5000;
 const PROTOCOL_V2_PROBE_TIMEOUT = 1000;
 const EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS = 2;
 let activeWebUsbTransport;
 let usbDisconnectListenerAttached = false;
+const identityProbeHandles = new WeakSet();
+const openingHandles = new WeakSet();
+const normalHandleOwners = new WeakMap();
 function registerActiveWebUsbTransport(instance, usb) {
     activeWebUsbTransport = instance;
     if (usbDisconnectListenerAttached)
@@ -72,17 +76,22 @@ function registerActiveWebUsbTransport(instance, usb) {
     });
 }
 class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
-    constructor() {
+    constructor(identityProbe = false) {
         super({
             router: transport.PROTOCOL_V2_CHANNEL_USB,
             maxFrameBytes: transport.PROTOCOL_V2_FRAME_MAX_BYTES,
             logPrefix: 'ProtocolV2 WebUSB',
         });
+        this.identityProbe = identityProbe;
         this.deviceProtocol = new Map();
         this.confirmedDeviceProtocols = new Map();
         this.deviceProtocolHints = new Map();
         this.staleProtocolPaths = new Set();
         this.acquiredPaths = new Set();
+        this.identityProbeDevices = new Map();
+        this.normalDevices = new Map();
+        this.pendingHandleOperations = new Set();
+        this.identityProbeCleanupPaths = new Set();
         this.probedDeviceObjects = new Map();
         this.deviceEndpoints = new Map();
         this.name = 'WebUsbTransport';
@@ -101,7 +110,104 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'WebUSB is not supported by current browsers');
         }
         this.usb = usb;
-        registerActiveWebUsbTransport(this, usb);
+        if (!this.identityProbe)
+            registerActiveWebUsbTransport(this, usb);
+    }
+    stop() {
+        this.stopped = true;
+        this.acquiredPaths.clear();
+        if (activeWebUsbTransport === this)
+            activeWebUsbTransport = undefined;
+        if (!this.stopPromise) {
+            this.stopPromise = this.stopResources().catch(error => {
+                this.stopPromise = undefined;
+                throw error;
+            });
+        }
+        return this.stopPromise;
+    }
+    stopResources() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let cleanupError;
+            try {
+                yield this.disposeProtocolV2UsbLinks('WebUSB transport stopped');
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+            yield Promise.allSettled([...this.pendingHandleOperations]);
+            const handles = this.identityProbe
+                ? [...this.identityProbeDevices].map(([path, device]) => [device, path])
+                : [...this.normalDevices];
+            for (const [device, path] of handles) {
+                if (!this.identityProbe && normalHandleOwners.get(device) !== this) {
+                    this.normalDevices.delete(device);
+                }
+                else {
+                    try {
+                        if (device.opened) {
+                            const iface = (_b = (_a = this.deviceEndpoints.get(path)) === null || _a === void 0 ? void 0 : _a.interfaceNumber) !== null && _b !== void 0 ? _b : this.interfaceId;
+                            try {
+                                yield device.releaseInterface(iface);
+                            }
+                            catch (error) {
+                                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] stop releaseInterface failed:', error);
+                            }
+                            yield device.close();
+                            if (device.opened)
+                                throw new Error('WebUSB handle remains open after stop');
+                        }
+                        if (this.identityProbe) {
+                            identityProbeHandles.delete(device);
+                            this.identityProbeDevices.delete(path);
+                            this.identityProbeCleanupPaths.delete(path);
+                        }
+                        else {
+                            normalHandleOwners.delete(device);
+                            this.normalDevices.delete(device);
+                        }
+                    }
+                    catch (error) {
+                        cleanupError !== null && cleanupError !== void 0 ? cleanupError : (cleanupError = error);
+                    }
+                }
+            }
+            this.deviceList = [];
+            this.deviceProtocol.clear();
+            this.confirmedDeviceProtocols.clear();
+            this.deviceProtocolHints.clear();
+            this.staleProtocolPaths.clear();
+            this.probedDeviceObjects.clear();
+            if (!this.normalDevices.size && !this.identityProbeDevices.size) {
+                this.deviceEndpoints.clear();
+            }
+            if (cleanupError) {
+                throw cleanupError instanceof Error
+                    ? cleanupError
+                    : new Error(this.getErrorMessage(cleanupError));
+            }
+        });
+    }
+    assertRunning() {
+        if (this.stopped) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'WebUSB transport is stopped');
+        }
+    }
+    runHandleOperation(operation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertRunning();
+            const pending = Promise.resolve(operation());
+            this.pendingHandleOperations.add(pending);
+            try {
+                const result = yield pending;
+                this.assertRunning();
+                return result;
+            }
+            finally {
+                this.pendingHandleOperations.delete(pending);
+            }
+        });
     }
     emitDeviceDisconnect(path, device) {
         var _a, _b;
@@ -150,15 +256,36 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
+            for (const path of this.identityProbeCleanupPaths) {
+                try {
+                    yield this.release(path);
+                }
+                catch (_a) {
+                }
+            }
             yield this.getConnectedDevices();
             return this.deviceList;
         });
     }
     getConnectedDevices() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertRunning();
             if (!this.usb)
                 return [];
             const devices = yield this.usb.getDevices();
+            this.assertRunning();
+            for (const owner of new Set(devices.map(device => normalHandleOwners.get(device)))) {
+                if (owner === null || owner === void 0 ? void 0 : owner.stopped) {
+                    try {
+                        yield owner.stop();
+                    }
+                    catch (error) {
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] stopped owner cleanup failed:', error);
+                    }
+                }
+            }
+            this.assertRunning();
             const onekeyDevices = devices.filter(dev => {
                 const isOneKey = hdShared.ONEKEY_WEBUSB_FILTER.some((desc) => dev.vendorId === desc.vendorId && dev.productId === desc.productId);
                 return isOneKey && !hdShared.isKnownTrezorWebUsbDevice(dev);
@@ -185,8 +312,16 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     acquire(input) {
         var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertRunning();
             if (!input.path)
                 return;
+            if (this.identityProbe) {
+                yield this.getConnectedDevices();
+                this.claimIdentityProbeHandle(input.path, yield this.findDevice(input.path));
+            }
+            else {
+                this.claimNormalHandle(input.path, yield this.findDevice(input.path));
+            }
             try {
                 yield this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
                 yield this.closeOpenDevice(input.path);
@@ -236,31 +371,44 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                         this.deviceProtocolHints.set(input.path, protocolHint);
                     }
                     const detectedProtocol = yield this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
+                    this.assertRunning();
                     this.confirmedDeviceProtocols.set(input.path, detectedProtocol);
                     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.assertRunning();
                 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);
+                try {
+                    yield this.closeOpenDevice(input.path);
+                }
+                finally {
+                    this.releaseIdentityProbeHandle(input.path);
+                    this.releaseNormalHandles(input.path);
+                }
                 throw e;
             }
         });
     }
     createProtocolMismatchError(expected) {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportProtocolProbeFailed, undefined, {
+            expectedProtocol: expected,
+        });
     }
     createProtocolProbeTimeoutError(expected, attempts) {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed, `Protocol ${expected} probe timeout after ${attempts} attempts`);
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportProtocolProbeFailed, undefined, {
+            expectedProtocol: expected,
+            attempts,
+        });
     }
     createProtocolDetectionError() {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportProtocolProbeFailed);
     }
     detectProtocol(path, expectedProtocol, protocolHint) {
         var _a;
@@ -328,10 +476,15 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         return __awaiter(this, void 0, void 0, function* () {
             const maxRetries = 5;
             for (let i = 0; i < maxRetries; i++) {
+                this.assertRunning();
                 try {
                     return yield this.connectToDevice(path, first);
                 }
                 catch (e) {
+                    this.assertRunning();
+                    if (e instanceof hdShared.HardwareError && e.errorCode === hdShared.HardwareErrorCode.BridgeNeedsPermission) {
+                        throw e;
+                    }
                     if (i === maxRetries - 1) {
                         throw e;
                     }
@@ -371,69 +524,174 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     connectToDevice(path, first) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertRunning();
             let device = yield this.findDevice(path);
+            if (this.identityProbe && this.identityProbeDevices.get(path) !== device) {
+                yield this.closeOpenDevice(path);
+                this.releaseIdentityProbeHandle(path);
+                this.claimIdentityProbeHandle(path, device);
+            }
+            if (!this.identityProbe)
+                this.claimNormalHandle(path, device);
+            this.assertHandleAvailable(device);
             if (!device.opened) {
-                yield device.open();
+                openingHandles.add(device);
+                try {
+                    yield this.runHandleOperation(() => device.open());
+                }
+                catch (error) {
+                    return yield this.throwWebUsbIoError(path, 'open', error);
+                }
+                finally {
+                    openingHandles.delete(device);
+                }
             }
             if (first || this.deviceProtocol.get(path) !== 'V1') {
                 try {
-                    yield device.reset();
+                    yield this.runHandleOperation(() => device.reset());
                 }
                 catch (error) {
+                    this.assertRunning();
                     (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] reset before claim failed, continuing:', error);
                 }
             }
             yield this.getConnectedDevices();
             device = yield this.findDevice(path);
+            if (this.identityProbe && this.identityProbeDevices.get(path) !== device) {
+                yield this.closeOpenDevice(path);
+                this.releaseIdentityProbeHandle(path);
+                this.claimIdentityProbeHandle(path, device);
+            }
+            if (!this.identityProbe)
+                this.claimNormalHandle(path, device);
+            this.assertHandleAvailable(device);
             if (!device.opened) {
-                yield device.open();
+                openingHandles.add(device);
+                try {
+                    yield this.runHandleOperation(() => device.open());
+                }
+                catch (error) {
+                    return yield this.throwWebUsbIoError(path, 'open', error);
+                }
+                finally {
+                    openingHandles.delete(device);
+                }
             }
             if (first ||
                 !device.configuration ||
                 device.configuration.configurationValue !== this.configurationId) {
-                yield device.selectConfiguration(this.configurationId);
+                yield this.runHandleOperation(() => device.selectConfiguration(this.configurationId));
             }
             const endpoints = this.discoverEndpoints(device);
             this.deviceEndpoints.set(path, endpoints);
-            yield device.claimInterface(endpoints.interfaceNumber);
+            try {
+                yield this.runHandleOperation(() => device.claimInterface(endpoints.interfaceNumber));
+            }
+            catch (error) {
+                return this.throwWebUsbIoError(path, 'claimInterface', error);
+            }
             yield this.clearEndpointHalt(device, 'in', endpoints.endpointIn);
             yield this.clearEndpointHalt(device, 'out', endpoints.endpointOut);
         });
     }
+    assertHandleAvailable(device) {
+        this.assertRunning();
+        const normalOwner = normalHandleOwners.get(device);
+        if ((normalOwner && normalOwner !== this) ||
+            (identityProbeHandles.has(device) &&
+                ![...this.identityProbeDevices.values()].includes(device))) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, USB_DEVICE_IN_USE);
+        }
+    }
+    claimNormalHandle(path, device) {
+        this.assertHandleAvailable(device);
+        normalHandleOwners.set(device, this);
+        this.normalDevices.set(device, path);
+    }
+    releaseNormalHandles(path) {
+        if (this.stopped)
+            return;
+        for (const [device, ownedPath] of this.normalDevices) {
+            if (ownedPath === path) {
+                normalHandleOwners.delete(device);
+                this.normalDevices.delete(device);
+            }
+        }
+    }
+    isHandleOwnershipError(error) {
+        return (error instanceof hdShared.HardwareError &&
+            error.errorCode === hdShared.HardwareErrorCode.RuntimeError &&
+            this.getErrorMessage(error).includes(USB_DEVICE_IN_USE));
+    }
+    claimIdentityProbeHandle(path, device) {
+        this.assertRunning();
+        if (device.opened ||
+            openingHandles.has(device) ||
+            identityProbeHandles.has(device) ||
+            normalHandleOwners.has(device)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, USB_DEVICE_IN_USE);
+        }
+        identityProbeHandles.add(device);
+        this.identityProbeDevices.set(path, device);
+    }
+    releaseIdentityProbeHandle(path) {
+        if (this.stopped)
+            return;
+        const device = this.identityProbeDevices.get(path);
+        if (device === null || device === void 0 ? void 0 : device.opened) {
+            this.identityProbeCleanupPaths.add(path);
+            return;
+        }
+        if (device)
+            identityProbeHandles.delete(device);
+        this.identityProbeDevices.delete(path);
+        this.identityProbeCleanupPaths.delete(path);
+    }
     closeOpenDevice(path) {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const current = (_a = this.deviceList.find(device => device.path === path)) === null || _a === void 0 ? void 0 : _a.device;
+            if (this.stopped)
+                return;
+            const current = this.identityProbe
+                ? this.identityProbeDevices.get(path)
+                : (_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;
+            this.assertHandleAvailable(current);
             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 current.releaseInterface(ifaceNum);
+                yield this.runHandleOperation(() => current.releaseInterface(ifaceNum));
             }
             catch (error) {
                 (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
             }
+            this.assertHandleAvailable(current);
             try {
-                yield current.close();
+                yield this.runHandleOperation(() => current.close());
             }
             catch (error) {
                 (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] close before reconnect failed:', error);
+                if (this.identityProbe)
+                    throw error;
             }
         });
     }
     clearEndpointHalt(device, direction, endpointNumber) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertHandleAvailable(device);
             try {
-                yield device.clearHalt(direction, endpointNumber);
+                yield this.runHandleOperation(() => device.clearHalt(direction, endpointNumber));
             }
             catch (error) {
+                this.assertRunning();
                 (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUsbTransport] clearHalt ${direction} endpoint ${endpointNumber} failed, continuing:`, error);
             }
         });
     }
     assertAcquired(path) {
+        this.assertRunning();
         if (!this.acquiredPaths.has(path)) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device is not acquired for ${path}`);
         }
@@ -459,8 +717,79 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         }
         return String(error);
     }
+    getErrorName(error) {
+        if (typeof error === 'object' && error && 'name' in error) {
+            const { name } = error;
+            return typeof name === 'string' ? name : String(name !== null && name !== void 0 ? name : '');
+        }
+        return '';
+    }
+    isWebUsbIoHardwareError(error) {
+        return (error instanceof hdShared.HardwareError &&
+            (error.errorCode === hdShared.HardwareErrorCode.BridgeDeviceDisconnected ||
+                error.errorCode === hdShared.HardwareErrorCode.BridgeNeedsPermission ||
+                error.errorCode === hdShared.HardwareErrorCode.WebUsbDeviceAccessError));
+    }
+    isDeviceStillEnumerated(path) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.usb)
+                return undefined;
+            try {
+                const devices = yield this.usb.getDevices();
+                return devices.some(device => hdShared.resolveOneKeyUsbDevicePath(device) === path);
+            }
+            catch (error) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] failed to verify WebUSB device presence:', error);
+                return undefined;
+            }
+        });
+    }
+    throwWebUsbIoError(path, operation, error) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.assertRunning();
+            if (this.isHandleOwnershipError(error) || this.isWebUsbIoHardwareError(error))
+                throw error;
+            if (error instanceof transport.ProtocolV2LinkError && error.code !== 'io')
+                throw error;
+            const nativeError = error instanceof transport.ProtocolV2LinkError ? (_a = error.cause) !== null && _a !== void 0 ? _a : error : error;
+            if (this.isWebUsbIoHardwareError(nativeError))
+                throw nativeError;
+            const nativeErrorName = this.getErrorName(nativeError);
+            const nativeErrorMessage = this.getErrorMessage(nativeError);
+            if (this.isWebUsbPermissionDeniedMessage(nativeErrorMessage)) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNeedsPermission, nativeErrorMessage, {
+                    operation,
+                    nativeErrorName: nativeErrorName || undefined,
+                    nativeErrorMessage,
+                });
+            }
+            const disconnectedByMessage = /(?:device )?disconnected|device not found|action was interrupted/i.test(`${nativeErrorName}: ${nativeErrorMessage}`);
+            const stillEnumerated = disconnectedByMessage
+                ? false
+                : yield this.isDeviceStillEnumerated(path);
+            const errorCode = disconnectedByMessage || stillEnumerated === false
+                ? hdShared.HardwareErrorCode.BridgeDeviceDisconnected
+                : hdShared.HardwareErrorCode.WebUsbDeviceAccessError;
+            throw hdShared.ERRORS.TypedError(errorCode, nativeErrorMessage || undefined, {
+                operation,
+                nativeErrorName: nativeErrorName || undefined,
+                nativeErrorMessage: nativeErrorMessage || undefined,
+            });
+        });
+    }
+    isWebUsbPermissionDeniedMessage(message) {
+        return /LIBUSB_ERROR_ACCESS|\b(?:access|permission) denied\b/i.test(message);
+    }
     isRetryablePacketIoError(error) {
+        if (this.stopped)
+            return false;
+        if (this.isHandleOwnershipError(error) || this.isWebUsbIoHardwareError(error))
+            return false;
         const message = this.getErrorMessage(error).toLowerCase();
+        if (this.isWebUsbPermissionDeniedMessage(message))
+            return false;
         return (message.includes('transferout') ||
             message.includes('transferin') ||
             message.includes('usbdevice') ||
@@ -475,21 +804,27 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             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);
+            this.assertRunning();
             try {
                 const currentDevice = yield this.findDevice(path);
+                this.assertHandleAvailable(currentDevice);
                 if (currentDevice.opened) {
                     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;
                     try {
-                        yield currentDevice.releaseInterface(ifaceNum);
+                        yield this.runHandleOperation(() => currentDevice.releaseInterface(ifaceNum));
                     }
                     catch (releaseError) {
                         this.Log.debug('[WebUsbTransport] releaseInterface before retry error:', releaseError);
                     }
-                    yield currentDevice.close();
+                    this.assertHandleAvailable(currentDevice);
+                    yield this.runHandleOperation(() => currentDevice.close());
                 }
             }
             catch (closeError) {
+                this.assertRunning();
+                if (this.isHandleOwnershipError(closeError))
+                    throw closeError;
                 this.Log.debug('[WebUsbTransport] close device before retry error:', closeError);
             }
             yield this.getConnectedDevices();
@@ -525,18 +860,21 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     lastError = error;
                     const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryablePacketIoError(error);
                     if (!shouldRetry) {
-                        throw error;
+                        return this.throwWebUsbIoError(path, 'transferOut', error);
                     }
                     try {
                         yield this.reconnectForPacketIoRetry(path, 'out', attempt, error);
                     }
                     catch (reconnectError) {
+                        this.assertRunning();
+                        if (this.isHandleOwnershipError(reconnectError))
+                            throw reconnectError;
                         lastError = reconnectError;
                         this.Log.debug(`[WebUsbTransport] transferout reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
                     }
                 }
             }
-            throw lastError;
+            return this.throwWebUsbIoError(path, 'transferOut', lastError);
         });
     }
     transferOutOnce(path, packet) {
@@ -549,7 +887,12 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             const endpoints = this.deviceEndpoints.get(path);
             const endpointOut = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointOut) !== null && _a !== void 0 ? _a : this.endpointId;
             const transferBuffer = this.toArrayBuffer(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
-            yield device.transferOut(endpointOut, transferBuffer);
+            this.assertHandleAvailable(device);
+            const result = yield device.transferOut(endpointOut, transferBuffer);
+            this.assertHandleAvailable(device);
+            if (result.status !== 'ok') {
+                return this.throwWebUsbIoError(path, 'transferOut', new Error(`transferOut status: ${String(result.status)}`));
+            }
         });
     }
     transferInWithRetry(path, length, cancelToken) {
@@ -567,7 +910,9 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     }
                     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;
+                    this.assertHandleAvailable(device);
                     const result = yield device.transferIn(endpointIn, length);
+                    this.assertHandleAvailable(device);
                     return this.getTransferInData(result);
                 }
                 catch (error) {
@@ -577,18 +922,21 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     }
                     const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryablePacketIoError(error);
                     if (!shouldRetry) {
-                        throw error;
+                        return this.throwWebUsbIoError(path, 'transferIn', error);
                     }
                     try {
                         yield this.reconnectForPacketIoRetry(path, 'in', attempt, error);
                     }
                     catch (reconnectError) {
+                        this.assertRunning();
+                        if (this.isHandleOwnershipError(reconnectError))
+                            throw reconnectError;
                         lastError = reconnectError;
                         this.Log.debug(`[WebUsbTransport] transferin reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
                     }
                 }
             }
-            throw lastError;
+            return this.throwWebUsbIoError(path, 'transferIn', lastError);
         });
     }
     transferInOnce(path, length) {
@@ -600,7 +948,9 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
             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;
+            this.assertHandleAvailable(device);
             const result = yield device.transferIn(endpointIn, length);
+            this.assertHandleAvailable(device);
             return this.getTransferInData(result);
         });
     }
@@ -660,12 +1010,14 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 return false;
             }
             try {
-                yield this.callProtocolV1(path, 'Initialize', {}, {
+                const response = yield this.callProtocolV1(path, this.identityProbe ? 'GetFeatures' : 'Initialize', {}, {
                     timeoutMs: PROTOCOL_V1_PROBE_TIMEOUT,
                 });
-                return true;
+                return !this.identityProbe || response.type === 'Features';
             }
-            catch (_error) {
+            catch (error) {
+                if (this.isWebUsbIoHardwareError(error))
+                    throw error;
                 return false;
             }
         });
@@ -680,6 +1032,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT,
                 logger: this.Log,
                 logPrefix: 'ProtocolV2 WebUSB',
+                shouldRethrow: error => this.isWebUsbIoHardwareError(error),
             });
         });
     }
@@ -726,7 +1079,15 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     callProtocolV2(path, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.callProtocolV2Usb(path, name, data, options);
+            try {
+                return yield this.callProtocolV2Usb(path, name, data, options);
+            }
+            catch (error) {
+                if (!(error instanceof transport.ProtocolV2LinkError) || error.code !== 'io')
+                    throw error;
+                const operation = error.message.includes(' USB write failed:') ? 'transferOut' : 'transferIn';
+                return this.throwWebUsbIoError(path, operation, error);
+            }
         });
     }
     receiveData(path, timeoutMs) {
@@ -769,8 +1130,14 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     release(path) {
         return __awaiter(this, void 0, void 0, function* () {
             this.acquiredPaths.delete(path);
-            yield this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
-            yield this.closeOpenDevice(path);
+            try {
+                yield this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
+                yield this.closeOpenDevice(path);
+            }
+            finally {
+                this.releaseIdentityProbeHandle(path);
+                this.releaseNormalHandles(path);
+            }
             this.deviceEndpoints.delete(path);
         });
     }
@@ -901,11 +1268,14 @@ class ElectronBleTransport {
                 if (error.code === hdShared.HardwareErrorCode.BlePermissionError) {
                     return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
                 }
+                if (error.code === hdShared.HardwareErrorCode.BleLocationError) {
+                    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError);
+                }
             }
             const errorMessage = error.message || String(error);
             const poweredOffMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BlePoweredOff];
             const unsupportedMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleUnsupported];
-            const permissionMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BlePermissionError];
+            const permissionMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleLocationError];
             if (errorMessage.includes(poweredOffMessage) || errorMessage.includes('poweredOff')) {
                 return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
             }
@@ -913,7 +1283,7 @@ class ElectronBleTransport {
                 return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
             }
             if (errorMessage.includes(permissionMessage) || errorMessage.includes('unauthorized')) {
-                return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
+                return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleLocationError);
             }
         }
         return error;
@@ -1174,10 +1544,12 @@ class ElectronBleTransport {
         });
     }
     createProtocolMismatchError(expected) {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportProtocolProbeFailed, undefined, {
+            expectedProtocol: expected,
+        });
     }
     createProtocolDetectionError() {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping');
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportProtocolProbeFailed);
     }
     clearProbeProtocol(uuid, protocol) {
         if (this.deviceProtocol.get(uuid) === protocol) {
@@ -1289,9 +1661,7 @@ class ElectronBleTransport {
                     (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
                     this.resetProtocolV2Frames(uuid);
                 },
-                shouldRethrow: error => expectedProtocol === 'V2' ||
-                    hdShared.isBleStaleBondHardwareError(error) ||
-                    transport.isProtocolV2LinkDisabledError(error),
+                shouldRethrow: error => expectedProtocol === 'V2' || transport.isProtocolV2LinkDisabledError(error),
             });
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');