@onekeyfe/hd-transport-web-device 1.2.8-alpha.100 → 1.2.8-alpha.102

package/dist/index.js

@@ -51,11 +51,18 @@ 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 WEBUSB_LIFECYCLE_LOG_PREFIX = '[WebUsbTransport][lifecycle]';
+const WEBUSB_ERROR_MESSAGE_LIMIT = 240;
 const PROTOCOL_V1_PROBE_TIMEOUT = 5000;
 const PROTOCOL_V2_PROBE_TIMEOUT = 1000;
 const EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS = 2;
 let activeWebUsbTransport;
 let usbDisconnectListenerAttached = false;
+let nextWebUsbTransportInstanceId = 0;
+const identityProbeHandles = new WeakSet();
+const openingHandles = new WeakSet();
+const normalHandleOwners = new WeakMap();
 function registerActiveWebUsbTransport(instance, usb) {
     activeWebUsbTransport = instance;
     if (usbDisconnectListenerAttached)
@@ -72,17 +79,26 @@ 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.transportInstanceId = ++nextWebUsbTransportInstanceId;
+        this.handleOperationSequence = 0;
+        this.deviceLogSequence = 0;
+        this.deviceLogIds = new WeakMap();
         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 +117,195 @@ 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() {
+        const startedAt = Date.now();
+        this.stopped = true;
+        this.acquiredPaths.clear();
+        if (activeWebUsbTransport === this)
+            activeWebUsbTransport = undefined;
+        if (!this.stopPromise) {
+            this.logLifecycle('stop', { phase: 'start' });
+            this.stopPromise = this.stopResources().then(() => {
+                this.logLifecycle('stop', {
+                    phase: 'success',
+                    durationMs: Date.now() - startedAt,
+                });
+            }, error => {
+                this.logLifecycle('stop', Object.assign({ phase: 'error', durationMs: Date.now() - startedAt }, this.getDiagnosticError(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;
+                            if (this.getInterfaceClaimed(device, iface) === false) {
+                                this.logSkippedHandleOperation('releaseInterface', device, 'interface-not-claimed', iface);
+                            }
+                            else {
+                                try {
+                                    yield this.runLoggedHandleOperation({
+                                        operation: 'releaseInterface',
+                                        device,
+                                        path,
+                                        interfaceNumber: iface,
+                                        allowStopped: true,
+                                        task: () => device.releaseInterface(iface),
+                                    });
+                                }
+                                catch (error) {
+                                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] stop releaseInterface failed:', error);
+                                }
+                            }
+                            yield this.runLoggedHandleOperation({
+                                operation: 'close',
+                                device,
+                                path,
+                                allowStopped: true,
+                                task: () => 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);
+            }
+        });
+    }
+    getInterfaceClaimed(device, interfaceNumber) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = device.configuration) === null || _a === void 0 ? void 0 : _a.interfaces) === null || _b === void 0 ? void 0 : _b.find(usbInterface => usbInterface.interfaceNumber === interfaceNumber)) === null || _c === void 0 ? void 0 : _c.claimed;
+    }
+    getDeviceLogId(device) {
+        const existing = this.deviceLogIds.get(device);
+        if (existing)
+            return existing;
+        const next = ++this.deviceLogSequence;
+        this.deviceLogIds.set(device, next);
+        return next;
+    }
+    getHandleLogState(device, interfaceNumber) {
+        var _a, _b;
+        const interfaceClaimed = interfaceNumber === undefined ? undefined : this.getInterfaceClaimed(device, interfaceNumber);
+        return {
+            deviceRefId: this.getDeviceLogId(device),
+            opened: device.opened,
+            configurationValue: (_b = (_a = device.configuration) === null || _a === void 0 ? void 0 : _a.configurationValue) !== null && _b !== void 0 ? _b : null,
+            interfaceNumber: interfaceNumber !== null && interfaceNumber !== void 0 ? interfaceNumber : null,
+            interfaceClaimed: interfaceClaimed !== null && interfaceClaimed !== void 0 ? interfaceClaimed : null,
+            identityProbe: this.identityProbe,
+            stopped: this.stopped,
+            acquiredPathCount: this.acquiredPaths.size,
+            normalHandleCount: this.normalDevices.size,
+            identityProbeHandleCount: this.identityProbeDevices.size,
+            pendingHandleOperationCount: this.pendingHandleOperations.size,
+        };
+    }
+    getDiagnosticError(error, path) {
+        const errorMessage = this.getErrorMessage(error);
+        const redactedMessage = path ? errorMessage.split(path).join('<device>') : errorMessage;
+        return {
+            errorName: this.getErrorName(error) || 'Error',
+            errorMessage: redactedMessage.slice(0, WEBUSB_ERROR_MESSAGE_LIMIT),
+            errorCode: error instanceof hdShared.HardwareError ? error.errorCode : undefined,
+        };
+    }
+    logLifecycle(event, payload = {}) {
+        var _a;
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(WEBUSB_LIFECYCLE_LOG_PREFIX, Object.assign({ event, transportInstanceId: this.transportInstanceId }, payload));
+    }
+    logSkippedHandleOperation(operation, device, reason, interfaceNumber) {
+        const operationId = ++this.handleOperationSequence;
+        this.logLifecycle('handle-operation', Object.assign({ operationId,
+            operation, phase: 'skipped', reason }, this.getHandleLogState(device, interfaceNumber)));
+    }
+    runLoggedHandleOperation({ operation, device, task, path, interfaceNumber, endpointNumber, allowStopped = false, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const operationId = ++this.handleOperationSequence;
+            const startedAt = Date.now();
+            const details = Object.assign({ operationId,
+                operation }, (endpointNumber === undefined ? {} : { endpointNumber }));
+            this.logLifecycle('handle-operation', Object.assign(Object.assign(Object.assign({}, details), { phase: 'start' }), this.getHandleLogState(device, interfaceNumber)));
+            try {
+                const result = allowStopped ? yield task() : yield this.runHandleOperation(task);
+                this.logLifecycle('handle-operation', Object.assign(Object.assign(Object.assign({}, details), { phase: 'success', durationMs: Date.now() - startedAt }), this.getHandleLogState(device, interfaceNumber)));
+                return result;
+            }
+            catch (error) {
+                this.logLifecycle('handle-operation', Object.assign(Object.assign(Object.assign(Object.assign({}, details), { phase: 'error', durationMs: Date.now() - startedAt }), this.getHandleLogState(device, interfaceNumber)), this.getDiagnosticError(error, path)));
+                throw error;
+            }
+        });
     }
     emitDeviceDisconnect(path, device) {
         var _a, _b;
@@ -138,11 +342,19 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.usb)
                 return null;
+            const startedAt = Date.now();
+            this.logLifecycle('prompt-device-access', { phase: 'start' });
             try {
                 const device = yield this.usb.requestDevice({ filters: hdShared.ONEKEY_WEBUSB_FILTER });
+                this.logLifecycle('prompt-device-access', {
+                    phase: 'success',
+                    durationMs: Date.now() - startedAt,
+                    selected: Boolean(device),
+                });
                 return device;
             }
             catch (e) {
+                this.logLifecycle('prompt-device-access', Object.assign({ phase: 'error', durationMs: Date.now() - startedAt }, this.getDiagnosticError(e)));
                 this.Log.debug('requestDevice error: ', e instanceof Error ? `${e.name}: ${e.message}` : String(e));
                 return null;
             }
@@ -150,15 +362,66 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.getConnectedDevices();
-            return this.deviceList;
+            const startedAt = Date.now();
+            this.logLifecycle('enumerate', {
+                phase: 'start',
+                pendingProbeCleanupCount: this.identityProbeCleanupPaths.size,
+            });
+            try {
+                for (const path of this.identityProbeCleanupPaths) {
+                    try {
+                        yield this.release(path);
+                    }
+                    catch (_a) {
+                    }
+                }
+                yield this.getConnectedDevices();
+                this.logLifecycle('enumerate', {
+                    phase: 'success',
+                    durationMs: Date.now() - startedAt,
+                    deviceCount: this.deviceList.length,
+                });
+                return this.deviceList;
+            }
+            catch (error) {
+                this.logLifecycle('enumerate', Object.assign({ phase: 'error', durationMs: Date.now() - startedAt }, this.getDiagnosticError(error)));
+                throw error;
+            }
         });
     }
     getConnectedDevices() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertRunning();
             if (!this.usb)
                 return [];
-            const devices = yield this.usb.getDevices();
+            const startedAt = Date.now();
+            this.logLifecycle('get-devices', { phase: 'start' });
+            let devices;
+            try {
+                devices = yield this.usb.getDevices();
+                this.logLifecycle('get-devices', {
+                    phase: 'success',
+                    durationMs: Date.now() - startedAt,
+                    authorizedDeviceCount: devices.length,
+                });
+            }
+            catch (error) {
+                this.logLifecycle('get-devices', Object.assign({ phase: 'error', durationMs: Date.now() - startedAt }, this.getDiagnosticError(error)));
+                throw error;
+            }
+            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);
@@ -183,14 +446,34 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         });
     }
     acquire(input) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertRunning();
             if (!input.path)
                 return;
+            const startedAt = Date.now();
+            this.logLifecycle('acquire', {
+                phase: 'start',
+                expectedProtocol: (_a = input.expectedProtocol) !== null && _a !== void 0 ? _a : null,
+                protocolHint: (_b = input.protocolHint) !== null && _b !== void 0 ? _b : null,
+                forceProtocolDetection: Boolean(input.forceProtocolDetection),
+                skipProtocolProbe: Boolean(input.skipProtocolProbe),
+                hasCachedProtocol: this.deviceProtocol.has(input.path),
+            });
             try {
+                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));
+                }
                 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);
+                yield this.connect((_c = input.path) !== null && _c !== void 0 ? _c : '', true, {
+                    expectedProtocol: input.expectedProtocol,
+                    forceProtocolDetection: input.forceProtocolDetection,
+                });
                 if (input.skipProtocolProbe) {
                     if (!input.expectedProtocol) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'skipProtocolProbe requires an expected protocol');
@@ -200,7 +483,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     }
                     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;
+                    const currentDevice = (_d = this.deviceList.find(d => d.path === input.path)) === null || _d === void 0 ? void 0 : _d.device;
                     if (currentDevice) {
                         this.probedDeviceObjects.set(input.path, currentDevice);
                     }
@@ -215,7 +498,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     this.deviceProtocol.delete(input.path);
                 }
                 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;
+                    const currentDevice = (_e = this.deviceList.find(d => d.path === input.path)) === null || _e === void 0 ? void 0 : _e.device;
                     if (!currentDevice || currentDevice !== this.probedDeviceObjects.get(input.path)) {
                         this.deviceProtocol.delete(input.path);
                     }
@@ -228,39 +511,58 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     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 usbDevice = (_f = this.deviceList.find(device => device.path === input.path)) === null || _f === void 0 ? void 0 : _f.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);
+                        : (_h = (_g = input.protocolHint) !== null && _g !== void 0 ? _g : this.deviceProtocolHints.get(input.path)) !== null && _h !== void 0 ? _h : 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);
                     }
                     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;
+                    const probedDevice = (_j = this.deviceList.find(d => d.path === input.path)) === null || _j === void 0 ? void 0 : _j.device;
                     if (probedDevice) {
                         this.probedDeviceObjects.set(input.path, probedDevice);
                     }
                 }
+                this.assertRunning();
                 this.acquiredPaths.add(input.path);
+                this.logLifecycle('acquire', {
+                    phase: 'success',
+                    durationMs: Date.now() - startedAt,
+                    protocol: (_k = this.deviceProtocol.get(input.path)) !== null && _k !== void 0 ? _k : null,
+                });
                 return yield Promise.resolve(input.path);
             }
             catch (e) {
+                this.logLifecycle('acquire', Object.assign({ phase: 'error', durationMs: Date.now() - startedAt }, this.getDiagnosticError(e, input.path)));
                 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;
@@ -324,18 +626,48 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             return device.device;
         });
     }
-    connect(path, first) {
+    connect(path, first, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const maxRetries = 5;
             for (let i = 0; i < maxRetries; i++) {
+                this.assertRunning();
+                const attempt = i + 1;
+                const startedAt = Date.now();
+                const connectionStrategy = this.shouldUseLegacyV1Connection(path, options)
+                    ? 'protocol-v1-legacy-1.1.31'
+                    : 'current';
+                this.logLifecycle('connect-attempt', {
+                    phase: 'start',
+                    attempt,
+                    maxAttempts: maxRetries,
+                    first,
+                    connectionStrategy,
+                });
                 try {
-                    return yield this.connectToDevice(path, first);
+                    const result = yield this.connectToDevice(path, first, options);
+                    this.logLifecycle('connect-attempt', {
+                        phase: 'success',
+                        attempt,
+                        maxAttempts: maxRetries,
+                        first,
+                        connectionStrategy,
+                        durationMs: Date.now() - startedAt,
+                    });
+                    return result;
                 }
                 catch (e) {
-                    if (e instanceof hdShared.HardwareError && e.errorCode === hdShared.HardwareErrorCode.BridgeNeedsPermission) {
+                    this.assertRunning();
+                    const isTerminalError = this.isHandleOwnershipError(e) ||
+                        (e instanceof hdShared.HardwareError &&
+                            (e.errorCode === hdShared.HardwareErrorCode.BridgeNeedsPermission ||
+                                e.errorCode === hdShared.HardwareErrorCode.WebUsbDeviceAccessError));
+                    const willRetry = !isTerminalError && attempt < maxRetries;
+                    this.logLifecycle('connect-attempt', Object.assign({ phase: 'error', attempt, maxAttempts: maxRetries, first,
+                        connectionStrategy, durationMs: Date.now() - startedAt, willRetry }, this.getDiagnosticError(e, path)));
+                    if (isTerminalError) {
                         throw e;
                     }
-                    if (i === maxRetries - 1) {
+                    if (!willRetry) {
                         throw e;
                     }
                     yield hdShared.wait(i * 200);
@@ -343,6 +675,11 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
         });
     }
+    shouldUseLegacyV1Connection(path, options) {
+        if (options.expectedProtocol)
+            return options.expectedProtocol === 'V1';
+        return !options.forceProtocolDetection && this.deviceProtocol.get(path) === 'V1';
+    }
     discoverEndpoints(device) {
         var _a, _b;
         for (const config of device.configurations) {
@@ -371,87 +708,276 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             endpointOut: this.endpointId,
         };
     }
-    connectToDevice(path, first) {
-        var _a;
+    connectToDevice(path, first, options = {}) {
         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) {
+                openingHandles.add(device);
                 try {
-                    yield device.open();
+                    yield this.runLoggedHandleOperation({
+                        operation: 'open',
+                        device,
+                        path,
+                        task: () => device.open(),
+                    });
                 }
                 catch (error) {
-                    return this.throwWebUsbIoError(path, 'open', error);
+                    return yield this.throwWebUsbIoError(path, 'open', error);
+                }
+                finally {
+                    openingHandles.delete(device);
+                }
+            }
+            if (this.shouldUseLegacyV1Connection(path, options)) {
+                if (first) {
+                    yield this.runLoggedHandleOperation({
+                        operation: 'selectConfiguration',
+                        device,
+                        path,
+                        task: () => device.selectConfiguration(this.configurationId),
+                    });
+                    try {
+                        yield this.runLoggedHandleOperation({
+                            operation: 'reset',
+                            device,
+                            path,
+                            task: () => device.reset(),
+                        });
+                    }
+                    catch (_a) {
+                        this.assertRunning();
+                    }
                 }
+                const legacyEndpoints = {
+                    interfaceNumber: this.interfaceId,
+                    endpointIn: this.endpointId,
+                    endpointOut: this.endpointId,
+                };
+                this.deviceEndpoints.set(path, legacyEndpoints);
+                yield this.claimDeviceInterface(path, device, legacyEndpoints);
+                return;
             }
             if (first || this.deviceProtocol.get(path) !== 'V1') {
                 try {
-                    yield device.reset();
+                    yield this.runLoggedHandleOperation({
+                        operation: 'reset',
+                        device,
+                        path,
+                        task: () => device.reset(),
+                    });
                 }
-                catch (error) {
-                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] reset before claim failed, continuing:', error);
+                catch (_b) {
+                    this.assertRunning();
                 }
             }
             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) {
+                openingHandles.add(device);
                 try {
-                    yield device.open();
+                    yield this.runLoggedHandleOperation({
+                        operation: 'open',
+                        device,
+                        path,
+                        task: () => device.open(),
+                    });
                 }
                 catch (error) {
-                    return this.throwWebUsbIoError(path, 'open', 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.runLoggedHandleOperation({
+                    operation: 'selectConfiguration',
+                    device,
+                    path,
+                    task: () => device.selectConfiguration(this.configurationId),
+                });
             }
             const endpoints = this.discoverEndpoints(device);
             this.deviceEndpoints.set(path, endpoints);
+            yield this.claimDeviceInterface(path, device, endpoints);
+            yield this.clearEndpointHalt(path, device, 'in', endpoints.endpointIn);
+            yield this.clearEndpointHalt(path, device, 'out', endpoints.endpointOut);
+        });
+    }
+    claimDeviceInterface(path, device, endpoints) {
+        return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield device.claimInterface(endpoints.interfaceNumber);
+                yield this.runLoggedHandleOperation({
+                    operation: 'claimInterface',
+                    device,
+                    path,
+                    interfaceNumber: endpoints.interfaceNumber,
+                    task: () => 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 && !device.opened) {
+                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 (!(current === null || current === void 0 ? void 0 : current.opened))
+            if (this.stopped)
+                return;
+            const devices = this.identityProbe
+                ? [this.identityProbeDevices.get(path)].filter((device) => device !== undefined)
+                : [...this.normalDevices]
+                    .filter(([, ownedPath]) => ownedPath === path)
+                    .map(([device]) => device);
+            let firstCloseError;
+            for (const device of devices) {
+                try {
+                    yield this.closeDeviceHandle(path, device);
+                }
+                catch (error) {
+                    firstCloseError !== null && firstCloseError !== void 0 ? firstCloseError : (firstCloseError = error);
+                }
+            }
+            if (firstCloseError) {
+                throw firstCloseError instanceof Error
+                    ? firstCloseError
+                    : new Error(this.getErrorMessage(firstCloseError));
+            }
+        });
+    }
+    closeDeviceHandle(path, current) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!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);
+            const ifaceNum = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _a !== void 0 ? _a : this.interfaceId;
+            if (this.getInterfaceClaimed(current, ifaceNum) === false) {
+                this.logSkippedHandleOperation('releaseInterface', current, 'interface-not-claimed', ifaceNum);
             }
-            catch (error) {
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
+            else {
+                try {
+                    yield this.runLoggedHandleOperation({
+                        operation: 'releaseInterface',
+                        device: current,
+                        path,
+                        interfaceNumber: ifaceNum,
+                        task: () => current.releaseInterface(ifaceNum),
+                    });
+                }
+                catch (error) {
+                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
+                }
             }
+            this.assertHandleAvailable(current);
             try {
-                yield current.close();
+                yield this.runLoggedHandleOperation({
+                    operation: 'close',
+                    device: current,
+                    path,
+                    task: () => current.close(),
+                });
             }
             catch (error) {
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] close before reconnect failed:', error);
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] close before reconnect failed:', error);
+                throw error;
             }
         });
     }
-    clearEndpointHalt(device, direction, endpointNumber) {
+    clearEndpointHalt(path, device, direction, endpointNumber) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertHandleAvailable(device);
             try {
-                yield device.clearHalt(direction, endpointNumber);
+                yield this.runLoggedHandleOperation({
+                    operation: direction === 'in' ? 'clearHaltIn' : 'clearHaltOut',
+                    device,
+                    path,
+                    endpointNumber,
+                    task: () => 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}`);
         }
@@ -508,7 +1034,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     throwWebUsbIoError(path, operation, error) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isWebUsbIoHardwareError(error))
+            this.assertRunning();
+            if (this.isHandleOwnershipError(error) || this.isWebUsbIoHardwareError(error))
                 throw error;
             if (error instanceof transport.ProtocolV2LinkError && error.code !== 'io')
                 throw error;
@@ -542,7 +1069,9 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         return /LIBUSB_ERROR_ACCESS|\b(?:access|permission) denied\b/i.test(message);
     }
     isRetryablePacketIoError(error) {
-        if (this.isWebUsbIoHardwareError(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))
@@ -561,21 +1090,43 @@ 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);
+                    if (this.getInterfaceClaimed(currentDevice, ifaceNum) === false) {
+                        this.logSkippedHandleOperation('releaseInterface', currentDevice, 'interface-not-claimed', ifaceNum);
                     }
-                    catch (releaseError) {
-                        this.Log.debug('[WebUsbTransport] releaseInterface before retry error:', releaseError);
+                    else {
+                        try {
+                            yield this.runLoggedHandleOperation({
+                                operation: 'releaseInterface',
+                                device: currentDevice,
+                                path,
+                                interfaceNumber: ifaceNum,
+                                task: () => currentDevice.releaseInterface(ifaceNum),
+                            });
+                        }
+                        catch (releaseError) {
+                            this.Log.debug('[WebUsbTransport] releaseInterface before retry error:', releaseError);
+                        }
                     }
-                    yield currentDevice.close();
+                    this.assertHandleAvailable(currentDevice);
+                    yield this.runLoggedHandleOperation({
+                        operation: 'close',
+                        device: currentDevice,
+                        path,
+                        task: () => 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();
@@ -617,6 +1168,9 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                         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)}`);
                     }
@@ -635,7 +1189,9 @@ 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));
+            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)}`));
             }
@@ -656,7 +1212,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) {
@@ -672,6 +1230,9 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                         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)}`);
                     }
@@ -689,7 +1250,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);
         });
     }
@@ -749,10 +1312,10 @@ 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) {
                 if (this.isWebUsbIoHardwareError(error))
@@ -868,9 +1431,25 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     release(path) {
         return __awaiter(this, void 0, void 0, function* () {
+            const startedAt = Date.now();
+            this.logLifecycle('release', { phase: 'start' });
             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);
+                this.logLifecycle('release', {
+                    phase: 'success',
+                    durationMs: Date.now() - startedAt,
+                });
+            }
+            catch (error) {
+                this.logLifecycle('release', Object.assign({ phase: 'error', durationMs: Date.now() - startedAt }, this.getDiagnosticError(error, path)));
+                throw error;
+            }
+            finally {
+                this.releaseIdentityProbeHandle(path);
+                this.releaseNormalHandles(path);
+            }
             this.deviceEndpoints.delete(path);
         });
     }
@@ -1277,10 +1856,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) {