@onekeyfe/hd-transport-usb 1.1.28 → 1.2.0-alpha.1

package/dist/index.d.ts

@@ -1,11 +1,10 @@
 import * as transport from '@onekeyfe/hd-transport';
-import transport__default, { OneKeyDeviceInfo, AcquireInput } from '@onekeyfe/hd-transport';
+import transport__default, { OneKeyDeviceInfo, AcquireInput, TransportCallOptions, ProtocolType } from '@onekeyfe/hd-transport';
 import EventEmitter from 'events';
 
-declare const PACKET_SIZE = 64;
-
 declare class NodeUsbTransport {
     messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    messagesV2: ReturnType<typeof transport__default.parseConfigure> | undefined;
     name: string;
     version: string;
     configured: boolean;
@@ -14,10 +13,15 @@ declare class NodeUsbTransport {
     emitter?: EventEmitter;
     private serialToBusId;
     private openDevices;
+    private deviceProtocol;
+    private protocolV2Assemblers;
+    private protocolV2Sessions;
+    private protocolV2ReadTimeouts;
     private reconnectLocks;
     private cancelled;
     init(logger: any, emitter?: EventEmitter): Promise<string>;
     configure(signedData: any): Promise<void>;
+    configureProtocolV2(signedData: any): void;
     listen(): void;
     stop(): void;
     post(path: string, name: string, data: Record<string, unknown>): Promise<void>;
@@ -30,16 +34,31 @@ declare class NodeUsbTransport {
     enumerate(): Promise<OneKeyDeviceInfo[]>;
     acquire(input: AcquireInput): Promise<string>;
     release(path: string, _onclose?: boolean): Promise<void>;
-    call(path: string, name: string, data: Record<string, unknown>): Promise<transport.MessageFromOneKey>;
+    private closeOpenDevice;
+    call(path: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<transport.MessageFromOneKey>;
+    private callProtocolV1;
     cancel(): void;
     private getOpenDevice;
     private getErrorMessage;
     private isRetryableError;
+    private getDeviceInterface;
     private reconnectForRetry;
     private sendAllChunksWithRetry;
     private transferInWithRetry;
     private openDevice;
+    private drainStaleInput;
+    private createProtocolMismatchError;
+    private createProtocolDetectionError;
+    private detectProtocol;
+    private resetConnectionAfterProbe;
+    private withProtocolReadTimeout;
+    private probeProtocolV1;
+    private probeProtocolV2;
+    private writeProtocolV2Frame;
+    private receiveProtocolV2Frame;
+    private callProtocolV2;
     private receiveData;
+    getProtocolType(path: string): ProtocolType | undefined;
 }
 
-export { PACKET_SIZE, NodeUsbTransport as default };
+export { NodeUsbTransport as default };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,SAA8B,MAAM,wBAAwB,CAAC;AAKpE,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AA0J7E,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAElE,IAAI,SAAsB;IAE1B,OAAO,SAAM;IAEb,UAAU,UAAS;IAEnB,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,OAAO,CAAC,aAAa,CAA6B;IAGlD,OAAO,CAAC,WAAW,CAAiC;IAGpD,OAAO,CAAC,cAAc,CAA0C;IAGhE,OAAO,CAAC,SAAS,CAAS;IAM1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAMxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAOzB,MAAM;IAIN,IAAI;IAQE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9E,IAAI,CAAC,IAAI,EAAE,MAAM;;;;;;IAiBjB,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA8B9C,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAkBvC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BxD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAkCpE,MAAM;IAWN,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,iBAAiB;YAmDX,sBAAsB;YAyCtB,mBAAmB;IAsCjC,OAAO,CAAC,UAAU;YAgEJ,WAAW;CAkC1B;AAED,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,SAWN,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AA0LhC,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAGlE,UAAU,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEpE,IAAI,SAAsB;IAE1B,OAAO,SAAM;IAEb,UAAU,UAAS;IAEnB,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,OAAO,CAAC,aAAa,CAA6B;IAGlD,OAAO,CAAC,WAAW,CAAiC;IAGpD,OAAO,CAAC,cAAc,CAAwC;IAG9D,OAAO,CAAC,oBAAoB,CAAoD;IAGhF,OAAO,CAAC,kBAAkB,CAA6C;IAGvE,OAAO,CAAC,sBAAsB,CAA8C;IAG5E,OAAO,CAAC,cAAc,CAA0C;IAGhE,OAAO,CAAC,SAAS,CAAS;IAM1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAMxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAOzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAOnC,MAAM;IAIN,IAAI;IAQE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9E,IAAI,CAAC,IAAI,EAAE,MAAM;;;;;;IAiBjB,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA8BxC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB7C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;YAMhD,eAAe;IA6BvB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YAwClB,cAAc;IA0B5B,MAAM;IAWN,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,iBAAiB;YAmDX,sBAAsB;YAyCtB,mBAAmB;YAsCnB,UAAU;YA0EV,eAAe;IAiB7B,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;YAOtB,cAAc;YA4Cd,yBAAyB;YAezB,uBAAuB;YA0CvB,eAAe;YAcf,eAAe;YAcf,oBAAoB;YA+BpB,sBAAsB;YAuCtB,cAAc;YAgDd,WAAW;IA6CzB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}

package/dist/index.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var ByteBuffer = require('bytebuffer');
 var usb = require('usb');
 var transport = require('@onekeyfe/hd-transport');
@@ -61,12 +59,11 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const PACKET_SIZE = 64;
-const REPORT_ID = 0x3f;
-const PAYLOAD_SIZE = PACKET_SIZE - 1;
-const HEADER_LENGTH = 6;
-
-const { parseConfigure, buildEncodeBuffers, decodeProtocol, receiveOne, check } = transport__default["default"];
+const { parseConfigure, ProtocolV1, check } = transport__default["default"];
+const PACKET_SIZE = transport.PROTOCOL_V1_USB_PACKET_SIZE;
+const REPORT_ID = transport.PROTOCOL_V1_REPORT_ID;
+const PAYLOAD_SIZE = transport.PROTOCOL_V1_CHUNK_PAYLOAD_SIZE;
+const HEADER_LENGTH = transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const INTERFACE_NUMBER = 0;
 const ENDPOINT_IN = 0x81;
 const ENDPOINT_OUT = 0x01;
@@ -74,6 +71,7 @@ const TRANSFER_TIMEOUT_MS = 30000;
 const SERIAL_READ_TIMEOUT_MS = 5000;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
+const PROTOCOL_PROBE_TIMEOUT = 1000;
 function getBusId(dev) {
     return `usb:${dev.busNumber}:${dev.deviceAddress}`;
 }
@@ -154,6 +152,26 @@ function transferOutOnce(ep, data) {
         });
     });
 }
+function resetUsbDevice(dev) {
+    return new Promise(resolve => {
+        const reset = dev.reset;
+        if (typeof reset !== 'function') {
+            resolve();
+            return;
+        }
+        reset.call(dev, () => resolve());
+    });
+}
+function clearEndpointHalt(ep) {
+    return new Promise(resolve => {
+        const clearHalt = ep.clearHalt;
+        if (typeof clearHalt !== 'function') {
+            resolve();
+            return;
+        }
+        clearHalt.call(ep, () => resolve());
+    });
+}
 function skipReportByte(packet) {
     if (packet[0] === REPORT_ID) {
         return packet.subarray(1);
@@ -171,6 +189,10 @@ class NodeUsbTransport {
         this.isOutdated = false;
         this.serialToBusId = new Map();
         this.openDevices = new Map();
+        this.deviceProtocol = new Map();
+        this.protocolV2Assemblers = new Map();
+        this.protocolV2Sessions = new Map();
+        this.protocolV2ReadTimeouts = new Map();
         this.reconnectLocks = new Map();
         this.cancelled = false;
     }
@@ -185,6 +207,13 @@ class NodeUsbTransport {
         this.messages = messages;
         return Promise.resolve();
     }
+    configureProtocolV2(signedData) {
+        var _a;
+        this.messagesV2 = parseConfigure(signedData);
+        this.protocolV2Sessions.clear();
+        this.protocolV2ReadTimeouts.clear();
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] Protocol V2 schema configured');
+    }
     listen() {
     }
     stop() {
@@ -194,7 +223,7 @@ class NodeUsbTransport {
             if (!this.messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const encodeBuffers = buildEncodeBuffers(this.messages, name, data);
+            const encodeBuffers = ProtocolV1.encodeMessageChunks(this.messages, name, data);
             yield this.sendAllChunksWithRetry(path, encodeBuffers);
         });
     }
@@ -208,7 +237,7 @@ class NodeUsbTransport {
             if (!this.messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            return receiveOne(this.messages, resData);
+            return ProtocolV1.decodeMessage(this.messages, resData);
         });
     }
     enumerate() {
@@ -238,20 +267,32 @@ class NodeUsbTransport {
     }
     acquire(input) {
         var _a, _b, _c;
-        const path = (_a = input.path) !== null && _a !== void 0 ? _a : '';
-        if (!path) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'No device path provided');
-        }
-        try {
-            this.openDevice(path);
-            return Promise.resolve(path);
-        }
-        catch (error) {
-            (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport acquire error: ', error);
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, (_c = error.message) !== null && _c !== void 0 ? _c : String(error));
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cancelled = false;
+            const path = (_a = input.path) !== null && _a !== void 0 ? _a : '';
+            if (!path) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'No device path provided');
+            }
+            try {
+                yield this.closeOpenDevice(path);
+                yield this.openDevice(path);
+                yield this.detectProtocol(path, input.expectedProtocol);
+                return path;
+            }
+            catch (error) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport acquire error: ', error);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, (_c = error.message) !== null && _c !== void 0 ? _c : String(error));
+            }
+        });
     }
     release(path, _onclose) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.closeOpenDevice(path);
+            this.deviceProtocol.delete(path);
+            this.protocolV2Assemblers.delete(path);
+        });
+    }
+    closeOpenDevice(path) {
         return __awaiter(this, void 0, void 0, function* () {
             const openDev = this.openDevices.get(path);
             if (!openDev)
@@ -278,7 +319,7 @@ class NodeUsbTransport {
             this.openDevices.delete(path);
         });
     }
-    call(path, name, data) {
+    call(path, name, data, options) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             this.cancelled = false;
@@ -288,20 +329,35 @@ class NodeUsbTransport {
             if (!this.openDevices.get(path)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
             }
-            const { messages } = this;
+            const protocol = this.deviceProtocol.get(path);
+            if (!protocol) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${path}`);
+            }
             if (transport.LogBlockCommand.has(name)) {
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport call-', ' name: ', name);
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport call-', ' name: ', name, ' protocol: ', protocol);
             }
             else {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data);
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
+            }
+            if (protocol === 'V2') {
+                return this.callProtocolV2(path, name, data, options);
             }
-            const encodeBuffers = buildEncodeBuffers(messages, name, data);
+            return this.callProtocolV1(path, name, data, options);
+        });
+    }
+    callProtocolV1(path, name, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { messages } = this;
+            if (!messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const encodeBuffers = ProtocolV1.encodeMessageChunks(messages, name, data);
             yield this.sendAllChunksWithRetry(path, encodeBuffers);
-            const resData = yield this.receiveData(path, this.getOpenDevice(path));
+            const resData = yield this.receiveData(path, this.getOpenDevice(path), options === null || options === void 0 ? void 0 : options.timeoutMs);
             if (typeof resData !== 'string') {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
             }
-            const jsonData = receiveOne(messages, resData);
+            const jsonData = ProtocolV1.decodeMessage(messages, resData);
             return check.call(jsonData);
         });
     }
@@ -341,6 +397,17 @@ class NodeUsbTransport {
             message.includes('timeout') ||
             message.includes('interrupt'));
     }
+    getDeviceInterface(dev) {
+        var _a;
+        const { interfaces } = dev;
+        if (!(interfaces === null || interfaces === void 0 ? void 0 : interfaces.length)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'USB interface not found');
+        }
+        const vendorInterface = interfaces.find(iface => iface.descriptor.bInterfaceClass === 0xff);
+        const defaultInterface = interfaces.find(iface => iface.descriptor.bInterfaceNumber === INTERFACE_NUMBER);
+        const iface = (_a = vendorInterface !== null && vendorInterface !== void 0 ? vendorInterface : defaultInterface) !== null && _a !== void 0 ? _a : interfaces[0];
+        return iface;
+    }
     reconnectForRetry(path, direction, attempt, error) {
         const existing = this.reconnectLocks.get(path);
         if (existing)
@@ -350,13 +417,13 @@ class NodeUsbTransport {
             (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] transfer${direction} failed, retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(error)}`);
             yield hdShared.wait(attempt * PACKET_IO_RETRY_DELAY);
             try {
-                yield this.release(path);
+                yield this.closeOpenDevice(path);
             }
             catch (releaseError) {
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[NodeUsbTransport] release before retry error:', releaseError);
             }
             yield this.enumerate();
-            this.openDevice(path);
+            yield this.openDevice(path);
             const openDev = this.openDevices.get(path);
             if (!openDev) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device not found after reconnect: ${path}`);
@@ -437,53 +504,312 @@ class NodeUsbTransport {
         });
     }
     openDevice(path) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const existing = this.openDevices.get(path);
+            if (existing)
+                return;
+            const busId = (_a = this.serialToBusId.get(path)) !== null && _a !== void 0 ? _a : path;
+            const allDevices = usb__namespace.getDeviceList();
+            const dev = allDevices.find(d => getBusId(d) === busId);
+            if (!dev) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `USB device not found: ${path}`);
+            }
+            try {
+                dev.open();
+                dev.timeout = TRANSFER_TIMEOUT_MS;
+                yield resetUsbDevice(dev);
+                try {
+                    dev.open();
+                }
+                catch (_d) {
+                }
+                dev.timeout = TRANSFER_TIMEOUT_MS;
+                const iface = this.getDeviceInterface(dev);
+                if (process.platform === 'linux') {
+                    try {
+                        if (iface.isKernelDriverActive()) {
+                            iface.detachKernelDriver();
+                        }
+                    }
+                    catch (_e) {
+                    }
+                }
+                iface.claim();
+                const epIn = (_b = iface.endpoints.find((e) => e.direction === 'in' && e.address === ENDPOINT_IN)) !== null && _b !== void 0 ? _b : iface.endpoints.find((e) => e.direction === 'in');
+                const epOut = (_c = iface.endpoints.find((e) => e.direction === 'out' && e.address === ENDPOINT_OUT)) !== null && _c !== void 0 ? _c : iface.endpoints.find((e) => e.direction === 'out');
+                if (!epIn || !epOut) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'USB endpoints not found (expected IN 0x81, OUT 0x01)');
+                }
+                epIn.timeout = TRANSFER_TIMEOUT_MS;
+                epOut.timeout = TRANSFER_TIMEOUT_MS;
+                yield clearEndpointHalt(epIn);
+                yield clearEndpointHalt(epOut);
+                yield this.drainStaleInput(epIn);
+                this.openDevices.set(path, { device: dev, iface, epIn, epOut });
+            }
+            catch (err) {
+                try {
+                    dev.close();
+                }
+                catch (_f) {
+                }
+                throw err;
+            }
+        });
+    }
+    drainStaleInput(epIn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const originalTimeout = epIn.timeout;
+            epIn.timeout = 50;
+            try {
+                for (let index = 0; index < 16; index += 1) {
+                    try {
+                        yield transferInOnce(epIn, PACKET_SIZE);
+                    }
+                    catch (_a) {
+                        break;
+                    }
+                }
+            }
+            finally {
+                epIn.timeout = originalTimeout;
+            }
+        });
+    }
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    }
+    createProtocolDetectionError() {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
+    }
+    detectProtocol(path, expectedProtocol) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (expectedProtocol === 'V1') {
+                if (yield this.probeProtocolV1(path)) {
+                    this.deviceProtocol.set(path, 'V1');
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1 (expected)`);
+                    return 'V1';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (expectedProtocol === 'V2') {
+                if (yield this.probeProtocolV2(path)) {
+                    this.deviceProtocol.set(path, 'V2');
+                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
+                    return 'V2';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (this.deviceProtocol.get(path) === 'V2' && (yield this.probeProtocolV2(path))) {
+                this.deviceProtocol.set(path, 'V2');
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (cached)`);
+                return 'V2';
+            }
+            if (yield this.probeProtocolV1(path)) {
+                this.deviceProtocol.set(path, 'V1');
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1`);
+                return 'V1';
+            }
+            if (yield this.probeProtocolV2(path)) {
+                this.deviceProtocol.set(path, 'V2');
+                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2`);
+                return 'V2';
+            }
+            this.deviceProtocol.delete(path);
+            throw this.createProtocolDetectionError();
+        });
+    }
+    resetConnectionAfterProbe(path) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
+            this.protocolV2Sessions.delete(path);
+            this.protocolV2ReadTimeouts.delete(path);
+            try {
+                yield this.closeOpenDevice(path);
+            }
+            catch (error) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[NodeUsbTransport] close after protocol probe error:', error);
+            }
+            yield this.enumerate();
+            yield this.openDevice(path);
+        });
+    }
+    withProtocolReadTimeout(path, promise, timeoutMs, protocol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            const waitForeverAfterTimeout = () => new Promise(() => { });
+            const guardedPromise = promise.then(value => (timedOut ? waitForeverAfterTimeout() : value), error => {
+                if (timedOut) {
+                    return waitForeverAfterTimeout();
+                }
+                throw error;
+            });
+            try {
+                return yield Promise.race([
+                    guardedPromise,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                            var _a;
+                            timedOut = true;
+                            try {
+                                yield this.resetConnectionAfterProbe(path);
+                            }
+                            catch (error) {
+                                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] reset after Protocol ${protocol} timeout failed:`, error);
+                            }
+                            finally {
+                                reject(new Error(`Protocol ${protocol} read timeout after ${timeoutMs}ms`));
+                            }
+                        }), timeoutMs);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    probeProtocolV1(path) {
         var _a;
-        const existing = this.openDevices.get(path);
-        if (existing)
-            return;
-        const busId = (_a = this.serialToBusId.get(path)) !== null && _a !== void 0 ? _a : path;
-        const allDevices = usb__namespace.getDeviceList();
-        const dev = allDevices.find(d => getBusId(d) === busId);
-        if (!dev) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `USB device not found: ${path}`);
-        }
-        dev.open();
-        try {
-            dev.timeout = TRANSFER_TIMEOUT_MS;
-            const iface = dev.interface(INTERFACE_NUMBER);
-            if (process.platform === 'linux') {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.messages) {
+                return false;
+            }
+            try {
+                yield this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
+                return true;
+            }
+            catch (error) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] Protocol V1 Initialize probe failed:', error);
+                return false;
+            }
+        });
+    }
+    probeProtocolV2(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.messages || !this.messagesV2) {
+                return false;
+            }
+            return transport.probeProtocolV2({
+                call: (name, data, options) => this.callProtocolV2(path, name, data, options),
+                timeoutMs: PROTOCOL_PROBE_TIMEOUT,
+                logger: this.Log,
+                logPrefix: 'ProtocolV2 NodeUSB',
+                onProbeFailed: () => this.resetConnectionAfterProbe(path),
+            });
+        });
+    }
+    writeProtocolV2Frame(path, frame) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let lastError;
+            for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
+                if (this.cancelled) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
+                }
                 try {
-                    if (iface.isKernelDriverActive()) {
-                        iface.detachKernelDriver();
+                    yield transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                    const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryableError(error);
+                    if (!shouldRetry) {
+                        throw error;
+                    }
+                    try {
+                        yield this.reconnectForRetry(path, 'out', attempt, error);
+                    }
+                    catch (reconnectError) {
+                        lastError = reconnectError;
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] Protocol V2 write reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
+                        break;
                     }
                 }
-                catch (_b) {
+            }
+            throw lastError;
+        });
+    }
+    receiveProtocolV2Frame(path, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let assembler = this.protocolV2Assemblers.get(path);
+            if (!assembler) {
+                assembler = new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES);
+                this.protocolV2Assemblers.set(path, assembler);
+            }
+            let frame = assembler.push(new Uint8Array(0));
+            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
+            while (!frame) {
+                const transferIn = this.transferInWithRetry(path, this.getOpenDevice(path), transport.PROTOCOL_V2_FRAME_MAX_BYTES);
+                const packet = deadline
+                    ? yield this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V2')
+                    : yield transferIn;
+                const bytes = new Uint8Array(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
+                try {
+                    frame = assembler.push(bytes);
+                }
+                catch (error) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, error instanceof Error ? error.message : String(error));
                 }
             }
-            iface.claim();
-            const epIn = iface.endpoints.find((e) => e.direction === 'in' && e.address === ENDPOINT_IN);
-            const epOut = iface.endpoints.find((e) => e.direction === 'out' && e.address === ENDPOINT_OUT);
-            if (!epIn || !epOut) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'USB endpoints not found (expected IN 0x81, OUT 0x01)');
+            return frame;
+        });
+    }
+    callProtocolV2(path, name, data, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const protocolV1Messages = this.messages;
+            if (!this.messagesV2) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Protocol V2 schema not configured');
             }
-            epIn.timeout = TRANSFER_TIMEOUT_MS;
-            epOut.timeout = TRANSFER_TIMEOUT_MS;
-            this.openDevices.set(path, { device: dev, iface, epIn, epOut });
-        }
-        catch (err) {
+            if (!protocolV1Messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            let session = this.protocolV2Sessions.get(path);
+            if (!session) {
+                session = new transport.ProtocolV2Session({
+                    schemas: {
+                        protocolV1: protocolV1Messages,
+                        protocolV2: this.messagesV2,
+                    },
+                    router: transport.PROTOCOL_V2_CHANNEL_USB,
+                    writeFrame: (frame) => this.writeProtocolV2Frame(path, frame),
+                    readFrame: () => this.receiveProtocolV2Frame(path, this.protocolV2ReadTimeouts.get(path)),
+                    logger: this.Log,
+                    logPrefix: 'ProtocolV2 NodeUSB',
+                    createTimeoutError: (messageName, timeoutMs) => new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${messageName}`),
+                });
+                this.protocolV2Sessions.set(path, session);
+            }
+            this.protocolV2ReadTimeouts.set(path, options === null || options === void 0 ? void 0 : options.timeoutMs);
+            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
             try {
-                dev.close();
+                return yield session.call(name, data, options);
             }
-            catch (_c) {
+            finally {
+                this.protocolV2ReadTimeouts.delete(path);
             }
-            throw err;
-        }
+        });
     }
-    receiveData(path, dev) {
+    receiveData(path, dev, timeoutMs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const firstPacket = yield this.transferInWithRetry(path, dev, PACKET_SIZE);
+            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
+            const readPacket = () => __awaiter(this, void 0, void 0, function* () {
+                const transferIn = this.transferInWithRetry(path, this.getOpenDevice(path), PACKET_SIZE);
+                return deadline
+                    ? this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V1')
+                    : transferIn;
+            });
+            const firstPacket = timeoutMs
+                ? yield readPacket()
+                : yield this.transferInWithRetry(path, dev, PACKET_SIZE);
             const firstData = skipReportByte(firstPacket);
-            const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(toArrayBuffer(firstData));
+            const { length, typeId, restBuffer } = ProtocolV1.decodeFirstChunk(toArrayBuffer(firstData));
             const lengthWithHeader = Number(length) + HEADER_LENGTH;
             const decoded = new ByteBuffer__default["default"](lengthWithHeader);
             decoded.writeUint16(typeId);
@@ -492,7 +818,7 @@ class NodeUsbTransport {
                 decoded.append(restBuffer);
             }
             while (decoded.offset < lengthWithHeader) {
-                const packet = yield this.transferInWithRetry(path, this.getOpenDevice(path), PACKET_SIZE);
+                const packet = yield readPacket();
                 const pktData = skipReportByte(packet);
                 const buf = toArrayBuffer(pktData);
                 if (lengthWithHeader - decoded.offset >= PAYLOAD_SIZE) {
@@ -507,7 +833,9 @@ class NodeUsbTransport {
             return Buffer.from(result).toString('hex');
         });
     }
+    getProtocolType(path) {
+        return this.deviceProtocol.get(path);
+    }
 }
 
-exports.PACKET_SIZE = PACKET_SIZE;
-exports["default"] = NodeUsbTransport;
+module.exports = NodeUsbTransport;