@onekeyfe/hd-transport-web-device 1.2.8-alpha.104 → 1.2.8-alpha.106

package/dist/index.js

@@ -52,11 +52,14 @@ 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();
@@ -83,6 +86,10 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             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();
@@ -114,12 +121,20 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             registerActiveWebUsbTransport(this, usb);
     }
     stop() {
+        const startedAt = Date.now();
         this.stopped = true;
         this.acquiredPaths.clear();
         if (activeWebUsbTransport === this)
             activeWebUsbTransport = undefined;
         if (!this.stopPromise) {
-            this.stopPromise = this.stopResources().catch(error => {
+            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;
             });
@@ -148,13 +163,31 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     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);
+                            if (this.getInterfaceClaimed(device, iface) === false) {
+                                this.logSkippedHandleOperation('releaseInterface', device, 'interface-not-claimed', iface);
                             }
-                            catch (error) {
-                                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] stop releaseInterface failed:', error);
+                            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 device.close();
+                            yield this.runLoggedHandleOperation({
+                                operation: 'close',
+                                device,
+                                path,
+                                allowStopped: true,
+                                task: () => device.close(),
+                            });
                             if (device.opened)
                                 throw new Error('WebUSB handle remains open after stop');
                         }
@@ -209,6 +242,71 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
         });
     }
+    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;
         (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit(transport.TRANSPORT_EVENT.DEVICE_DISCONNECT, {
@@ -244,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;
             }
@@ -256,15 +362,31 @@ 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) {
+            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;
             }
-            yield this.getConnectedDevices();
-            return this.deviceList;
         });
     }
     getConnectedDevices() {
@@ -273,7 +395,21 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             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) {
@@ -310,22 +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;
-            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));
-            }
+            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');
@@ -335,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);
                     }
@@ -350,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);
                     }
@@ -363,31 +511,40 @@ 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);
                 try {
                     yield this.closeOpenDevice(input.path);
                 }
+                catch (cleanupError) {
+                    this.logLifecycle('acquire-cleanup', Object.assign({ phase: 'error' }, this.getDiagnosticError(cleanupError, input.path)));
+                }
                 finally {
                     this.releaseIdentityProbeHandle(input.path);
                     this.releaseNormalHandles(input.path);
@@ -472,20 +629,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) {
                     this.assertRunning();
-                    if (e instanceof hdShared.HardwareError && e.errorCode === hdShared.HardwareErrorCode.BridgeNeedsPermission) {
+                    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);
@@ -493,6 +678,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) {
@@ -521,8 +711,7 @@ 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);
@@ -537,7 +726,12 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (!device.opened) {
                 openingHandles.add(device);
                 try {
-                    yield this.runHandleOperation(() => device.open());
+                    yield this.runLoggedHandleOperation({
+                        operation: 'open',
+                        device,
+                        path,
+                        task: () => device.open(),
+                    });
                 }
                 catch (error) {
                     return yield this.throwWebUsbIoError(path, 'open', error);
@@ -546,13 +740,42 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     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 = this.discoverEndpoints(device);
+                this.deviceEndpoints.set(path, legacyEndpoints);
+                yield this.claimDeviceInterface(path, device, legacyEndpoints);
+                return;
+            }
             if (first || this.deviceProtocol.get(path) !== 'V1') {
                 try {
-                    yield this.runHandleOperation(() => device.reset());
+                    yield this.runLoggedHandleOperation({
+                        operation: 'reset',
+                        device,
+                        path,
+                        task: () => device.reset(),
+                    });
                 }
-                catch (error) {
+                catch (_b) {
                     this.assertRunning();
-                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] reset before claim failed, continuing:', error);
                 }
             }
             yield this.getConnectedDevices();
@@ -568,7 +791,12 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (!device.opened) {
                 openingHandles.add(device);
                 try {
-                    yield this.runHandleOperation(() => device.open());
+                    yield this.runLoggedHandleOperation({
+                        operation: 'open',
+                        device,
+                        path,
+                        task: () => device.open(),
+                    });
                 }
                 catch (error) {
                     return yield this.throwWebUsbIoError(path, 'open', error);
@@ -580,18 +808,34 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (first ||
                 !device.configuration ||
                 device.configuration.configurationValue !== this.configurationId) {
-                yield this.runHandleOperation(() => 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 this.runHandleOperation(() => 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) {
@@ -612,7 +856,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         if (this.stopped)
             return;
         for (const [device, ownedPath] of this.normalDevices) {
-            if (ownedPath === path) {
+            if (ownedPath === path && !device.opened) {
                 normalHandleOwners.delete(device);
                 this.normalDevices.delete(device);
             }
@@ -648,41 +892,82 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         this.identityProbeCleanupPaths.delete(path);
     }
     closeOpenDevice(path) {
-        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             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))
+            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 this.runHandleOperation(() => 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 this.runHandleOperation(() => 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);
-                if (this.identityProbe)
-                    throw 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 this.runHandleOperation(() => device.clearHalt(direction, endpointNumber));
+                yield this.runLoggedHandleOperation({
+                    operation: direction === 'in' ? 'clearHaltIn' : 'clearHaltOut',
+                    device,
+                    path,
+                    endpointNumber,
+                    task: () => device.clearHalt(direction, endpointNumber),
+                });
             }
             catch (error) {
                 this.assertRunning();
@@ -811,14 +1096,30 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 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 this.runHandleOperation(() => 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);
+                        }
                     }
                     this.assertHandleAvailable(currentDevice);
-                    yield this.runHandleOperation(() => currentDevice.close());
+                    yield this.runLoggedHandleOperation({
+                        operation: 'close',
+                        device: currentDevice,
+                        path,
+                        task: () => currentDevice.close(),
+                    });
                 }
             }
             catch (closeError) {
@@ -1129,10 +1430,20 @@ 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);
             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);