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

package/dist/index.js

@@ -52,14 +52,11 @@ 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();
@@ -86,10 +83,6 @@ 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();
@@ -121,20 +114,12 @@ 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.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 = this.stopResources().catch(error => {
                 this.stopPromise = undefined;
                 throw error;
             });
@@ -163,31 +148,13 @@ 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;
-                            if (this.getInterfaceClaimed(device, iface) === false) {
-                                this.logSkippedHandleOperation('releaseInterface', device, 'interface-not-claimed', iface);
+                            try {
+                                yield device.releaseInterface(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);
-                                }
+                            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(),
-                            });
+                            yield device.close();
                             if (device.opened)
                                 throw new Error('WebUSB handle remains open after stop');
                         }
@@ -242,71 +209,6 @@ 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, {
@@ -342,19 +244,11 @@ 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;
             }
@@ -362,31 +256,15 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
-            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) {
-                    }
+            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() {
@@ -395,21 +273,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             this.assertRunning();
             if (!this.usb)
                 return [];
-            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;
-            }
+            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) {
@@ -446,34 +310,22 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         });
     }
     acquire(input) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g;
         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),
-            });
+            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 {
-                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((_c = input.path) !== null && _c !== void 0 ? _c : '', true, {
-                    expectedProtocol: input.expectedProtocol,
-                    forceProtocolDetection: input.forceProtocolDetection,
-                });
+                yield this.connect((_a = input.path) !== null && _a !== void 0 ? _a : '', true);
                 if (input.skipProtocolProbe) {
                     if (!input.expectedProtocol) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'skipProtocolProbe requires an expected protocol');
@@ -483,7 +335,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     }
                     this.staleProtocolPaths.delete(input.path);
                     this.deviceProtocol.set(input.path, input.expectedProtocol);
-                    const currentDevice = (_d = this.deviceList.find(d => d.path === input.path)) === null || _d === void 0 ? void 0 : _d.device;
+                    const currentDevice = (_b = this.deviceList.find(d => d.path === input.path)) === null || _b === void 0 ? void 0 : _b.device;
                     if (currentDevice) {
                         this.probedDeviceObjects.set(input.path, currentDevice);
                     }
@@ -498,7 +350,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     this.deviceProtocol.delete(input.path);
                 }
                 if (!input.skipProtocolProbe && this.deviceProtocol.has(input.path)) {
-                    const currentDevice = (_e = this.deviceList.find(d => d.path === input.path)) === null || _e === void 0 ? void 0 : _e.device;
+                    const currentDevice = (_c = this.deviceList.find(d => d.path === input.path)) === null || _c === void 0 ? void 0 : _c.device;
                     if (!currentDevice || currentDevice !== this.probedDeviceObjects.get(input.path)) {
                         this.deviceProtocol.delete(input.path);
                     }
@@ -511,32 +363,26 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     this.deviceProtocol.delete(input.path);
                 }
                 if (!this.deviceProtocol.has(input.path)) {
-                    const usbDevice = (_f = this.deviceList.find(device => device.path === input.path)) === null || _f === void 0 ? void 0 : _f.device;
+                    const usbDevice = (_d = this.deviceList.find(device => device.path === input.path)) === null || _d === void 0 ? void 0 : _d.device;
                     const protocolHint = input.expectedProtocol
                         ? undefined
-                        : (_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);
+                        : (_f = (_e = input.protocolHint) !== null && _e !== void 0 ? _e : this.deviceProtocolHints.get(input.path)) !== null && _f !== void 0 ? _f : hdShared.inferProtocolHintFromUsbId(usbDevice === null || usbDevice === void 0 ? void 0 : usbDevice.vendorId, usbDevice === null || usbDevice === void 0 ? void 0 : usbDevice.productId);
                     if (protocolHint) {
                         this.deviceProtocolHints.set(input.path, protocolHint);
                     }
                     const detectedProtocol = yield this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
                     this.assertRunning();
                     this.confirmedDeviceProtocols.set(input.path, detectedProtocol);
-                    const probedDevice = (_j = this.deviceList.find(d => d.path === input.path)) === null || _j === void 0 ? void 0 : _j.device;
+                    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);
-                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 {
@@ -626,48 +472,20 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             return device.device;
         });
     }
-    connect(path, first, options = {}) {
+    connect(path, first) {
         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 {
-                    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;
+                    return yield this.connectToDevice(path, first);
                 }
                 catch (e) {
                     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) {
+                    if (e instanceof hdShared.HardwareError && e.errorCode === hdShared.HardwareErrorCode.BridgeNeedsPermission) {
                         throw e;
                     }
-                    if (!willRetry) {
+                    if (i === maxRetries - 1) {
                         throw e;
                     }
                     yield hdShared.wait(i * 200);
@@ -675,11 +493,6 @@ 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) {
@@ -708,7 +521,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             endpointOut: this.endpointId,
         };
     }
-    connectToDevice(path, first, options = {}) {
+    connectToDevice(path, first) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.assertRunning();
             let device = yield this.findDevice(path);
@@ -723,12 +537,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (!device.opened) {
                 openingHandles.add(device);
                 try {
-                    yield this.runLoggedHandleOperation({
-                        operation: 'open',
-                        device,
-                        path,
-                        task: () => device.open(),
-                    });
+                    yield this.runHandleOperation(() => device.open());
                 }
                 catch (error) {
                     return yield this.throwWebUsbIoError(path, 'open', error);
@@ -737,46 +546,13 @@ 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 = {
-                    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 this.runLoggedHandleOperation({
-                        operation: 'reset',
-                        device,
-                        path,
-                        task: () => device.reset(),
-                    });
+                    yield this.runHandleOperation(() => device.reset());
                 }
-                catch (_b) {
+                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();
@@ -792,12 +568,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (!device.opened) {
                 openingHandles.add(device);
                 try {
-                    yield this.runLoggedHandleOperation({
-                        operation: 'open',
-                        device,
-                        path,
-                        task: () => device.open(),
-                    });
+                    yield this.runHandleOperation(() => device.open());
                 }
                 catch (error) {
                     return yield this.throwWebUsbIoError(path, 'open', error);
@@ -809,34 +580,18 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (first ||
                 !device.configuration ||
                 device.configuration.configurationValue !== this.configurationId) {
-                yield this.runLoggedHandleOperation({
-                    operation: 'selectConfiguration',
-                    device,
-                    path,
-                    task: () => device.selectConfiguration(this.configurationId),
-                });
+                yield this.runHandleOperation(() => 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.runLoggedHandleOperation({
-                    operation: 'claimInterface',
-                    device,
-                    path,
-                    interfaceNumber: endpoints.interfaceNumber,
-                    task: () => device.claimInterface(endpoints.interfaceNumber),
-                });
+                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) {
@@ -857,7 +612,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         if (this.stopped)
             return;
         for (const [device, ownedPath] of this.normalDevices) {
-            if (ownedPath === path && !device.opened) {
+            if (ownedPath === path) {
                 normalHandleOwners.delete(device);
                 this.normalDevices.delete(device);
             }
@@ -893,82 +648,41 @@ 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 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)
+            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 = (_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);
+            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));
             }
-            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);
-                }
+            catch (error) {
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
             }
             this.assertHandleAvailable(current);
             try {
-                yield this.runLoggedHandleOperation({
-                    operation: 'close',
-                    device: current,
-                    path,
-                    task: () => current.close(),
-                });
+                yield this.runHandleOperation(() => current.close());
             }
             catch (error) {
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[WebUsbTransport] close before reconnect failed:', error);
-                throw error;
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] close before reconnect failed:', error);
+                if (this.identityProbe)
+                    throw error;
             }
         });
     }
-    clearEndpointHalt(path, device, direction, endpointNumber) {
+    clearEndpointHalt(device, direction, endpointNumber) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.assertHandleAvailable(device);
             try {
-                yield this.runLoggedHandleOperation({
-                    operation: direction === 'in' ? 'clearHaltIn' : 'clearHaltOut',
-                    device,
-                    path,
-                    endpointNumber,
-                    task: () => device.clearHalt(direction, endpointNumber),
-                });
+                yield this.runHandleOperation(() => device.clearHalt(direction, endpointNumber));
             }
             catch (error) {
                 this.assertRunning();
@@ -1097,30 +811,14 @@ 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;
-                    if (this.getInterfaceClaimed(currentDevice, ifaceNum) === false) {
-                        this.logSkippedHandleOperation('releaseInterface', currentDevice, 'interface-not-claimed', ifaceNum);
+                    try {
+                        yield this.runHandleOperation(() => currentDevice.releaseInterface(ifaceNum));
                     }
-                    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);
-                        }
+                    catch (releaseError) {
+                        this.Log.debug('[WebUsbTransport] releaseInterface before retry error:', releaseError);
                     }
                     this.assertHandleAvailable(currentDevice);
-                    yield this.runLoggedHandleOperation({
-                        operation: 'close',
-                        device: currentDevice,
-                        path,
-                        task: () => currentDevice.close(),
-                    });
+                    yield this.runHandleOperation(() => currentDevice.close());
                 }
             }
             catch (closeError) {
@@ -1431,20 +1129,10 @@ 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);